konokenj.cdk-api-mcp-server 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-servicecatalogappregistry-alpha/README.md

@@ -0,0 +1,355 @@
+# AWS ServiceCatalogAppRegistry Construct Library
+<!--BEGIN STABILITY BANNER-->
+
+---
+
+![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg?style=for-the-badge)
+
+> The APIs of higher level constructs in this module are experimental and under active development.
+> They are subject to non-backward compatible changes or removal in any future version. These are
+> not subject to the [Semantic Versioning](https://semver.org/) model and breaking changes will be
+> announced in the release notes. This means that while you may use them, you may need to update
+> your source code when upgrading to a newer version of this package.
+
+---
+
+<!--END STABILITY BANNER-->
+
+[AWS Service Catalog App Registry](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/appregistry.html)
+enables organizations to create and manage repositories of applications and associated resources.
+
+## Table Of Contents
+
+- [Application](#application)
+- [Application-Associator](#application-associator)
+- [Attribute-Group](#attribute-group)
+- [Associations](#associations)
+  - [Associating application with an attribute group](#attribute-group-association)
+  - [Associating application with a stack](#resource-association)
+- [Sharing](#sharing)
+  - [Sharing an application](#sharing-an-application)
+  - [Sharing an attribute group](#sharing-an-attribute-group)
+
+The `@aws-cdk/aws-servicecatalogappregistry-alpha` package contains resources that enable users to automate governance and management of their AWS resources at scale.
+
+```ts nofixture
+import * as appreg from '@aws-cdk/aws-servicecatalogappregistry-alpha';
+```
+
+## Application
+
+An AppRegistry application enables you to define your applications and associated resources.
+The application name must be unique at the account level and it's immutable.
+
+```ts
+const application = new appreg.Application(this, 'MyFirstApplication', {
+  applicationName: 'MyFirstApplicationName',
+  description: 'description for my application', // the description is optional
+});
+```
+
+An application that has been created outside of the stack can be imported into your CDK app.
+Applications can be imported by their ARN via the `Application.fromApplicationArn()` API:
+
+```ts
+const importedApplication = appreg.Application.fromApplicationArn(
+  this,
+  'MyImportedApplication',
+  'arn:aws:servicecatalog:us-east-1:012345678910:/applications/0aqmvxvgmry0ecc4mjhwypun6i',
+);
+```
+
+## Application-Associator
+
+`ApplicationAssociator` defines an AppRegistry application to contain all the stacks in deployed through your cdk package. This helps to manage all the 
+cdk deployed resources.
+
+### Create a new application to associate all the stacks in the cdk.App scope
+
+If you want to create an Application named `MyAssociatedApplication` in account `123456789012` and region `us-east-1`
+and want to associate all stacks in the `App` scope to `MyAssociatedApplication`, then use as shown in the example below:
+
+```ts
+const app = new App();
+const associatedApp = new appreg.ApplicationAssociator(app, 'AssociatedApplication', {
+  applications: [appreg.TargetApplication.createApplicationStack({
+    applicationName: 'MyAssociatedApplication',
+    // 'Application containing stacks deployed via CDK.' is the default
+    applicationDescription: 'Associated Application description',
+    stackName: 'MyAssociatedApplicationStack',
+    // AWS Account and Region that are implied by the current CLI configuration is the default
+    env: { account: '123456789012', region: 'us-east-1' },
+  })],
+});
+```
+
+This will create a stack `MyAssociatedApplicationStack` containing an application `MyAssociatedApplication` 
+with the `TagKey` as `managedBy` and `TagValue` as `CDK_Application_Associator`.
+
+By default, the stack will have System Managed Application Manager console URL as its output for the application created. 
+If you want to remove the output, then use as shown in the example below:
+
+```ts
+const app = new App();
+const associatedApp = new appreg.ApplicationAssociator(app, 'AssociatedApplication', {
+  applications: [appreg.TargetApplication.createApplicationStack({
+    applicationName: 'MyAssociatedApplication',
+    // 'Application containing stacks deployed via CDK.' is the default
+    applicationDescription: 'Associated Application description',
+    stackName: 'MyAssociatedApplicationStack',
+    // Disables emitting Application Manager url as output
+    emitApplicationManagerUrlAsOutput: false,
+    // AWS Account and Region that are implied by the current CLI configuration is the default
+    env: { account: '123456789012', region: 'us-east-1' },
+  })],
+});
+```
+
+### Import existing application to associate all the stacks in the cdk.App scope
+
+If you want to re-use an existing Application with ARN: `arn:aws:servicecatalog:us-east-1:123456789012:/applications/applicationId`
+and want to associate all stacks in the `App` scope to your imported application, then use as shown in the example below:
+
+```ts
+const app = new App();
+const associatedApp = new appreg.ApplicationAssociator(app, 'AssociatedApplication', {
+  applications: [appreg.TargetApplication.existingApplicationFromArn({
+    applicationArnValue: 'arn:aws:servicecatalog:us-east-1:123456789012:/applications/applicationId',
+    stackName: 'MyAssociatedApplicationStack',
+  })],
+});
+```
+
+### Associate attribute group to the application used by `ApplicationAssociator`
+
+If you want to associate an Attribute Group with application created by `ApplicationAssociator`, then use as shown in the example below:
+
+```ts
+import * as cdk from "aws-cdk-lib";
+
+const app = new App();
+
+const associatedApp = new appreg.ApplicationAssociator(app, 'AssociatedApplication', {
+  applications: [appreg.TargetApplication.createApplicationStack({
+    applicationName: 'MyAssociatedApplication',
+    // 'Application containing stacks deployed via CDK.' is the default
+    applicationDescription: 'Associated Application description',
+    stackName: 'MyAssociatedApplicationStack',
+    // AWS Account and Region that are implied by the current CLI configuration is the default
+    env: { account: '123456789012', region: 'us-east-1' },
+  })],
+});
+
+// Associate application to the attribute group.
+associatedApp.appRegistryApplication.addAttributeGroup('MyAttributeGroup' , {
+  attributeGroupName: 'MyAttributeGroupName',
+  description: 'Test attribute group',
+  attributes: {},
+});
+
+```
+
+### Associate stacks deployed by CDK pipelines
+
+If you are using CDK Pipelines to deploy your application, the application stacks will be inside Stages, and
+ApplicationAssociator will not be able to find them. Call `associateStage` on each Stage object before adding it to the
+Pipeline, as shown in the example below:
+
+```ts
+import * as cdk from "aws-cdk-lib";
+import * as codepipeline from "aws-cdk-lib/pipelines";
+import * as codecommit from "aws-cdk-lib/aws-codecommit";
+declare const repo: codecommit.Repository;
+declare const pipeline: codepipeline.CodePipeline;
+declare const beta: cdk.Stage;
+class ApplicationPipelineStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string, props: ApplicationPipelineStackProps) {
+    super(scope, id, props);
+
+   //associate the stage to application associator.
+   props.application.associateStage(beta);
+   pipeline.addStage(beta);
+  }
+};
+
+interface ApplicationPipelineStackProps extends cdk.StackProps {
+  application: appreg.ApplicationAssociator;
+};
+
+const app = new App();
+const associatedApp = new appreg.ApplicationAssociator(app, 'AssociatedApplication', {
+  applications: [appreg.TargetApplication.createApplicationStack({
+    applicationName: 'MyPipelineAssociatedApplication',
+    stackName: 'MyPipelineAssociatedApplicationStack',
+    env: { account: '123456789012', region: 'us-east-1' },
+  })],
+});
+
+const cdkPipeline = new ApplicationPipelineStack(app, 'CDKApplicationPipelineStack', {
+    application: associatedApp,
+    env: {account: '123456789012', region: 'us-east-1'},
+});
+```
+
+### Associate cross-account stack
+
+By default, ApplicationAssociator will not perform cross-account stack associations with the target Application,
+to avoid deployment failures for accounts which have not been setup for cross-account associations.
+To enable cross-account stack associations, make sure all accounts are in the same organization as the
+target Application's account and that resource sharing is enabled within the organization.
+If you wish to turn on cross-account sharing and associations, set the `associateCrossAccountStacks` field to `true`,
+as shown in the example below:
+
+```ts
+const app = new App();
+const associatedApp = new appreg.ApplicationAssociator(app, 'AssociatedApplication', {
+  applications: [appreg.TargetApplication.createApplicationStack({
+    associateCrossAccountStacks: true,
+    applicationName: 'MyAssociatedApplication',
+    env: { account: '123456789012', region: 'us-east-1' },
+  })],
+});
+```
+
+### Associate cross-region stack
+
+Currently, cross-region stack association is not supported.
+
+## Attribute Group
+
+An AppRegistry attribute group acts as a container for user-defined attributes for an application.
+Metadata is attached in a machine-readable format to integrate with automated workflows and tools.
+The attribute group name must be unique at the account level and it's immutable.
+
+```ts
+const attributeGroup = new appreg.AttributeGroup(this, 'MyFirstAttributeGroup', {
+  attributeGroupName: 'MyFirstAttributeGroupName',
+  description: 'description for my attribute group', // the description is optional,
+  attributes: {
+    project: 'foo',
+    team: ['member1', 'member2', 'member3'],
+    public: false,
+    stages: {
+      alpha: 'complete',
+      beta: 'incomplete',
+      release: 'not started'
+    }
+  }
+});
+```
+
+An attribute group that has been created outside of the stack can be imported into your CDK app.
+Attribute groups can be imported by their ARN via the `AttributeGroup.fromAttributeGroupArn()` API:
+
+```ts
+const importedAttributeGroup = appreg.AttributeGroup.fromAttributeGroupArn(
+  this,
+  'MyImportedAttrGroup',
+  'arn:aws:servicecatalog:us-east-1:012345678910:/attribute-groups/0aqmvxvgmry0ecc4mjhwypun6i',
+);
+```
+
+## Associations
+
+You can associate your appregistry application with attribute groups and resources.
+Resources are CloudFormation stacks that you can associate with an application to group relevant
+stacks together to enable metadata rich insights into your applications and resources.
+A Cloudformation stack can only be associated with one appregistry application.
+If a stack is associated with multiple applications in your app or is already associated with one,
+CDK will fail at deploy time.
+
+### Associating application with a new attribute group
+
+You can create and associate an attribute group to an application with the `addAttributeGroup()` API:
+
+```ts
+declare const application: appreg.Application;
+declare const attributeGroup: appreg.AttributeGroup;
+application.addAttributeGroup('MyAttributeGroupId' , {
+    attributeGroupName: 'MyAttributeGroupName',
+    description: 'Test attribute group',
+    attributes: {},
+});
+```
+
+### Associating an attribute group with application
+
+You can associate an application with an attribute group with `associateWith`:
+
+```ts
+declare const application: appreg.Application;
+declare const attributeGroup: appreg.AttributeGroup;
+attributeGroup.associateWith(application);
+```
+
+### Associating application with a Stack
+
+You can associate a stack with an application with the `associateApplicationWithStack()` API:
+
+```ts
+const app = new App();
+const myStack = new Stack(app, 'MyStack');
+
+declare const application: appreg.Application;
+application.associateApplicationWithStack(myStack);
+```
+
+## Sharing
+
+You can share your AppRegistry applications and attribute groups with AWS Organizations, Organizational Units (OUs), AWS accounts within an organization, as well as IAM roles and users. AppRegistry requires that AWS Organizations is enabled in an account before deploying a share of an application or attribute group.
+
+### Sharing an application
+
+```ts
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const application: appreg.Application;
+declare const myRole: iam.IRole;
+declare const myUser: iam.IUser;
+application.shareApplication('MyShareId', {
+  name:'MyShare',
+  accounts: ['123456789012'],
+  organizationArns: ['arn:aws:organizations::123456789012:organization/o-my-org-id'],
+  roles: [myRole],
+  users: [myUser],
+});
+```
+
+E.g., sharing an application with multiple accounts and allowing the accounts to associate resources to the application.
+
+```ts
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const application: appreg.Application;
+application.shareApplication('MyShareId', {
+  name: 'MyShare',
+  accounts: ['123456789012', '234567890123'],
+  sharePermission: appreg.SharePermission.ALLOW_ACCESS,
+});
+```
+
+### Sharing an attribute group
+
+```ts
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const attributeGroup: appreg.AttributeGroup;
+declare const myRole: iam.IRole;
+declare const myUser: iam.IUser;
+attributeGroup.shareAttributeGroup('MyShareId', {
+  name: 'MyShare',
+  accounts: ['123456789012'],
+  organizationArns: ['arn:aws:organizations::123456789012:organization/o-my-org-id'],
+  roles: [myRole],
+  users: [myUser],
+});
+```
+
+E.g., sharing an application with multiple accounts and allowing the accounts to associate applications to the attribute group.
+
+```ts
+import * as iam from 'aws-cdk-lib/aws-iam';
+declare const attributeGroup: appreg.AttributeGroup;
+attributeGroup.shareAttributeGroup('MyShareId', {
+  name: 'MyShare',
+  accounts: ['123456789012', '234567890123'],
+  sharePermission: appreg.SharePermission.ALLOW_ACCESS,
+});
+```

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/cfnspec/README.md

@@ -0,0 +1,2 @@
+This package has been replaced by a more modern version.
+Please use `@aws-cdk/aws-service-spec` ([source](https://github.com/cdklabs/awscdk-service-spec)) instead.

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/custom-resource-handlers/README.md

@@ -0,0 +1,83 @@
+# CDK Handler Framework
+
+The CDK handler framework is an internal framework used to code generate constructs that extend a lambda `Function`, lambda `SingletonFunction`, or core `CustomResourceProvider` construct and prohibit the user from directly configuring the `handler`, `runtime`, `code`, and `codeDirectory` properties.  In doing this, we are able to establish best practices, runtime enforcement, and consistency across all handlers we build and vend within the aws-cdk.
+
+## CDK Handler Framework Concepts
+
+This framework allows for the creation of three component types:
+1. `ComponentType.FUNCTION` - This is a wrapper around the lambda `Function` construct. It offers the same behavior and performance as a lambda `Function`, but it restricts the consumer from configuring the `handler`, `runtime`, and `code` properties.
+2. `ComponentType.SINGLETON_FUNCTION` - This is a wrapper around the lambda `SingletonFunction` construct. It offers the same behavior and performance as a lambda `SingletonFunction`, but it restricts the consumer from configuring the `handler`, `runtime`, and `code` properties.
+3. `ComponentType.CUSTOM_RESOURCE_PROVIDER` - This is a wrapper around the core `CustomResourceProvider` construct. It offers the same behavior and performance as a `CustomResourceProvider` and can be instantiated via the `getOrCreate` or `getOrCreateProvider` methods. This component restricts the consumer from configuring the `runtime` and `codeDirectory` properties.
+
+Code generating one of these three component types requires adding the component properties to the [config](./config.ts) file by providing `ComponentProps`. The `ComponentProps` are responsible for code generating the specified `ComponentType` with the `handler`, `runtime`, `code`, and `codeDirectory` properties set internally. `ComponentProps` includes the following properties:
+- `type` - the framework component type to generate.
+- `sourceCode` - the source code that will be excuted by the framework component.
+- `runtime` - the runtime that is compatible with the framework component's source code. This is an optional property with a default node runtime that will be the latest available node runtime in the `Stack` deployment region. In general, you should not configure this property unless a `runtime` override is absolutely necessary.
+- `handler` - the name of the method with the source code that the framework component will call. This is an optional property and the default is `index.handler`.
+- `minifyAndBundle` - whether the source code should be minified and bundled. This an optional property and the default is `true`. This should only be set to `false` for python files or for typescript/javascript files with a require import.
+
+The [config](./config.ts) file is structured with the top level mapping to an aws-cdk module, i.e., aws-s3, aws-dynamodb, etc. Each service can contain one or more component modules. Component modules are containers for handler framework components and will be rendered as a code generated file. Each component module can contain one or more `ComponentProps` objects. The following example shows a more structural breakdown of how the [config](./config.ts) file is configured:
+
+```ts
+const config = {
+  'aws-s3': { // the aws-cdk-lib module
+    'replica-provider': [ // the component module
+      // handler framework component defined as a `ComponentProps` object
+      {
+        // the handler framework component type
+        type: ComponentType.FUNCTION,
+        // the source code that the component will use
+        sourceCode: path.resolve(__dirname, '..', 'aws-dynamodb', 'replica-handler', 'index.ts'),
+        // the handler in the source code that the component will execute
+        handler: 'index.onEventHandler',
+      },
+    ],
+  },
+  'aws-stepfunctions-tasks': {
+    // contains multiple component modules
+    'eval-nodejs-provider': [
+      {
+        type: ComponentType.SINGLETON_FUNCTION,
+        sourceCode: path.resolve(__dirname, '..', 'aws-stepfunctions-tasks', 'eval-nodejs-handler', 'index.ts'),
+      },
+    ],
+    'role-policy-provider': [
+      {
+        type: ComponentType.SINGLETON_FUNCTION,
+        sourceCode: path.resolve(__dirname, '..', 'aws-stepfunctions-tasks', 'role-policy-handler', 'index.py'),
+        runtime: Runtime.PYTHON_3_9,
+        // prevent minify and bundle since the source code is a python file
+        minifyAndBundle: false,
+      },
+    ],
+  },
+};
+```
+
+Code generation for the component modules is triggered when this package - `@aws-cdk/custom-resource-handlers` - is built. Importantly, this framework is also responsible for minifying and bundling the custom resource providers' source code and dependencies. A flag named `minifyAndBundle` can be configured as part of the `ComponentProps` to prevent minifying and bundling the source code for a specific provider. This flag is only needed for python files or for typescript/javascript files containing require imports.
+
+Once built, all generated code and bundled source code will be written to `@aws-cdk/custom-resource-handlers/dist`. The top level field in the [config](./config.ts) file defining individual aws-cdk modules will be used to create specific directories within `@aws-cdk/custom-resource-handlers/dist` and each component module will be a separate code generated file within these directories named `<component-module>.generated.ts`. As an example, the sample [config](./config.ts) file above would create the following file structure:
+
+|--- @aws-cdk
+|   |--- custom-resource-handlers
+|   |   |--- dist
+|   |   |   |--- aws-s3
+|   |   |   |   |--- replica-handler
+|   |   |   |   |   |--- index.js
+|   |   |   |   |--- replica-provider.generated.ts
+|   |   |   |--- aws-stepfunctions-tasks
+|   |   |   |   |--- eval-nodejs-handler
+|   |   |   |   |   |--- index.js
+|   |   |   |   |--- role-policy-handler
+|   |   |   |   |   |--- index.py
+|   |   |   |   |--- eval-nodejs-provider.generated.ts
+|   |   |   |   |--- role-policy-provider.generated.ts
+
+The code generated handler framework components are consumable from `aws-cdk-lib/custom-resource-handlers/dist` once `aws-cdk-lib` is built. The file structure of `aws-cdk-lib/custom-resource-handlers/dist` will have the same structure as `@aws-cdk/custom-resource-handlers/dist` with the exception of `core`. To prevent circular dependencies, all handler framework components defined in `core`and any associated source code will be consumable from `aws-cdk-lib/core/dist/core`.
+
+## Creating a Handler Framework Component
+
+Creating a new handler framework component involves three steps:
+1. Add the source code to `@aws-cdk/custom-resource-handlers/lib/<aws-cdk-lib-module>`
+2. Update the [config](./config.ts) file by specifying all required `ComponentProps`.
+3. At this point you can directly build `@aws-cdk/custom-resource-handlers` with `yarn build` to view the generated component in `@aws-cdk/custom-resource-handlers/dist`. Alternatively, you can build `aws-cdk-lib` with `npx lerna run build --scope=aws-cdk-lib --skip-nx-cache` to make the generated component available for use within `aws-cdk-lib`

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/example-construct-library/README.md

@@ -0,0 +1,92 @@
+# An example Construct Library module
+
+<!--BEGIN STABILITY BANNER-->
+
+---
+
+![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg?style=for-the-badge)
+
+> The APIs of higher level constructs in this module are experimental and under active development. They are subject to non-backward compatible changes or removal in any future version. These are not subject to the [Semantic Versioning](https://semver.org/) model and breaking changes will be announced in the release notes. This means that while you may use them, you may need to update your source code when upgrading to a newer version of this package.
+
+---
+
+<!--END STABILITY BANNER-->
+
+This package contains an example CDK construct library
+for an imaginary resource called ExampleResource.
+Its target audience are construct library authors -
+both when contributing to the core CDK codebase,
+or when writing your own construct library.
+
+Even though different construct libraries model vastly different services,
+a large percentage of the structure of the construct libraries
+(what we often call Layer 2 constructs, or L2s for short)
+is actually strikingly similar between all of them.
+This module hopes to present a skeleton of that structure,
+that you can literally copy&paste to your own construct library,
+and then edit to suit your needs.
+It also attempts to explain the elements of that skeleton as best as it can,
+through inline comments on the code itself.
+
+## Using when contributing to the CDK codebase
+
+If you're creating a completely new module,
+feel free to copy&paste this entire directory,
+and then edit the `package.json` and `README.md`
+files as necessary (see the "Package structure" section below).
+Make sure to remove the `"private": true` line from `package.json`
+after copying, as otherwise your package will not be published!
+
+If you're contributing a new resource to an existing package,
+feel free to copy&paste the following files,
+instead of the entire package:
+
+* [`lib/example-resource.ts`](lib/example-resource.ts)
+* [`lib/private/example-resource-common.ts`](lib/private/example-resource-common.ts)
+* [`test/example-resource.test.ts`](test/example-resource.test.ts)
+* [`test/integ.example-resource.ts`](test/integ.example-resource.ts)
+* [`test/integ.example-resource.expected.json`](test/integ.example-resource.expected.json)
+
+And proceed to edit and rename them from there.
+
+## Using for your own construct libraries
+
+Feel free to use this package as the basis of your own construct library;
+note, however, that you will have to change a few things in `package.json` to get it to build:
+
+* Remove the `"private": true` flag if you intend to publish your package to npmjs.org
+  (see https://docs.npmjs.com/files/package.json#private for details).
+* Remove the `devDependencies` on `cdk-build-tools`, `cdk-integ-tools` and `pkglint`.
+* Remove the `lint`, `integ`, `pkglint`, `package`, `build+test+package`, `awslint`, and `compat` entries in the `scripts` section.
+* The `build` script should be just `tsc`, `watch` just `tsc -w`, and `test` just `jest`.
+* Finally, the `awscdkio` key should be completely removed.
+
+You will also have to get rid of the integration test files,
+[`test/integ.example-resource.ts`](test/integ.example-resource.ts) and
+[`test/integ.example-resource.expected.json`](test/integ.example-resource.expected.json),
+as those styles of integration tests are not available outside the CDK main repo.
+
+## Code structure
+
+The code structure is explained through inline comments in the files themselves.
+Probably [`lib/example-resource.ts`](lib/example-resource.ts) is a good place to start reading.
+
+### Tests
+
+The package contains examples of unit tests in the [`test/example-resource.test.ts`](test/example-resource.test.ts)
+file.
+
+It also contains an example integration test in [`test/integ.example-resource.ts`](test/integ.example-resource.ts).
+For more information on CDK integ tests, see the
+[main `Contributing.md` file](../../../CONTRIBUTING.md#integration-tests).
+
+## Package structure
+
+The package uses the standard build and test tools available in the CDK repo.
+Even though it's not published,
+it also uses [JSII](https://github.com/aws/jsii),
+the technology that allows CDK logic to be written once,
+but used from multiple programming languages.
+Its configuration lives the `jsii` key in `package.json`.
+It's mainly used as a validation tool in this package,
+as JSII places some constraints on the TypeScript code that you can write.