open-index/open-npm huggingface dataset:
npm package: @jjrawlins/cdk-git-tagger
Description: CDK Aspect to tag resources with git metadata.  This provides a nice connection between the construct and the git repository.
Author: Jayson Rawlins
Latest version: 0.0.141

# CDK Aspect Git Tagger

This is a CDK Aspect that will tag your CDK Stacks with the current git repo location for easier identification of
deployed stacks. Will create a `.git-url-tagger.json` file in the root of your project to store the git url.  This file
will be used to determine the git url for the stack.

### How to install

```shell
npm install @jjrawlins/cdk-git-tagger
```

or

```shell
yarn add @jjrawlins/cdk-git-tagger
```

### How to use

```typescript
import { GitUrlTagger } from '@jjrawlins/cdk-git-tagger';
import { App, Aspects, Stack, StackProps } from 'aws-cdk-lib';
import { Topic } from 'aws-cdk-lib/aws-sns';
import { Construct } from 'constructs';

export class MyStack extends Stack {
    constructor(scope: Construct, id: string, props: StackProps = {}) {
        super(scope, id, props);
        // define resources here...
        new Topic(this, 'MyTopic');
    }
}

const app = new App();

new MyStack(app, 'cdk-aspect-git-tagger-tester');
Aspects.of(app).add(new GitUrlTagger());
app.synth();
```

### Example Output

```json
{
  "Resources": {
    "MyTopic86869434": {
      "Type": "AWS::SNS::Topic",
      "Properties": {
        "Tags": [
          {
            "Key": "GitUrl",
            "Value": "https://github.com/jjrawlins/cdk-cool-construct.git"
          }
        ]
      }
    }
  }
}
```
npm package: @jjrawlins/cdk-iam-policy-builder-helper
Description: A CDK construct that helps build IAM policies using the AWS IAM Policy Builder dump. Normally it is better to use cdk-iam-floyd, However, I found that cdk-iam-floyd currently is not jsii compliant so I wasn't able to use it in my jsii compliant projects i
Author: Jayson Rawlins
Latest version: 0.1.0

# cdk-iam-policy-builder-helper

The AWS CDK allows you to define your cloud infrastructure using familiar programming languages, and this project
leverages that! Here are some examples of how to use our Actions and Managed Policies helper properties through
TypeScript, Python, and Golang.  Since this construct is jsii compliant, hopefully, this can be leveraged eventually in all the jsii compliant languages.

### Example

The following is the TypeScript version:

```typescript
import { App, Stack, Effect } from 'aws-cdk-lib';
import { ManagedPolicy, Role, ServicePrincipal, PolicyDocument, PolicyStatement, } from 'aws-cdk-lib/aws-iam';
import { Actions, ManagedPolicies } from '../src';

const app = new App();
const stack = new Stack(app, 'MyStack');

// Create an IAM role using helper classes
new Role(stack, 'MyRole', {
    assumedBy: new ServicePrincipal('ec2.amazonaws.com'),
    managedPolicies: [
        ManagedPolicy.fromManagedPolicyArn(stack, 'ElastiCacheFullAccess', ManagedPolicies.AmazonElastiCacheFullAccess.Arn),
        ManagedPolicy.fromManagedPolicyArn(stack, 'FSxConsoleFullAccess', ManagedPolicies.AmazonFSxConsoleFullAccess.Arn),
    ],
    inlinePolicies: {
        ec2DescribeInstances: new PolicyDocument({
            statements: [
                new PolicyStatement({
                    effect: Effect.ALLOW,
                    actions: [
                        Actions.ec2.DescribeInstances,
                        Actions.ec2.CopyImage,
                        Actions.ec2.RunInstances,
                        Actions.ec2.CreateTags,
                        Actions.ec2.CreateCustomerGateway,
                    ],
                    resources: ['*'],
                }),
                new PolicyStatement({
                    effect: Effect.ALLOW,
                    actions: [Actions.s3.GetObject, Actions.s3.PutObject, Actions.s3.DeleteObject],
                    resources: ['*'],
                }),
            ],
        }),
    },
});
```
npm package: @jjrawlins/projen-cdktn-app-ts
Description: CDK Terrain (CDKTN) app project type for projen in TypeScript
Author: Jayson Rawlins
Latest version: 0.0.7

# @jjrawlins/projen-cdktn-app-ts

A reusable [projen](https://projen.io) project type for building
[CDK Terrain](https://cdktn.io) applications in TypeScript.

It generates:

- a TypeScript app project configured for CDK Terrain
- a `cdktf.json` file wired to `ts-node`
- standard `cdktn` tasks: `get`, `synth`, `diff`, `deploy`, `destroy`, `watch`
- starter application and test files when the project is empty

## Quick Start

Scaffold a new CDK Terrain app in an empty directory:

```sh
npx projen new --from @jjrawlins/projen-cdktn-app-ts
```

## Install

Or add to an existing project:

```sh
# npm
npm install --save-dev projen @jjrawlins/projen-cdktn-app-ts

# yarn
yarn add --dev projen @jjrawlins/projen-cdktn-app-ts
```

## Usage

Create a `.projenrc.ts`:

```ts
import { CdktnTypeScriptApp } from '@jjrawlins/projen-cdktn-app-ts';

const project = new CdktnTypeScriptApp({
  name: 'my-cdktn-app',
  defaultReleaseBranch: 'main',
  projenrcTs: true,
  cdktnVersion: '0.22.0',
  terraformProviders: ['hashicorp/aws@~>5.0'],
});

project.synth();
```

Then synthesize the project:

```sh
npx projen
```

## Common Options

- `appEntrypoint` — overrides the default `src/main.ts` entrypoint
- `cdktnVersion` — pins the `cdktn` and `cdktn-cli` versions
- `constructsVersion` — pins the `constructs` dependency
- `terraformProviders` — adds providers to `cdktf.json`
- `terraformModules` — adds modules to `cdktf.json`
- `cdktfOut` — customizes the synthesis output directory
- `context` — merges additional context values into `cdktf.json`

## Generated Tasks

After synthesis, the generated project includes:

| Task | npm | yarn |
|------|-----|------|
| Generate providers | `npx projen get` | `yarn get` |
| Synthesize | `npx projen synth` | `yarn synth` |
| Diff | `npx projen diff` | `yarn diff` |
| Deploy | `npx projen deploy -- --auto-approve` | `yarn deploy -- --auto-approve` |
| Destroy | `npx projen destroy -- --auto-approve` | `yarn destroy -- --auto-approve` |
| Watch | `npx projen watch` | `yarn watch` |

## API

Detailed generated API docs are available in [API.md](./API.md).