https://github.com/iac-factory/cdktf
A Functional Wrapper around CDKTF
https://github.com/iac-factory/cdktf
Last synced: 2 months ago
JSON representation
A Functional Wrapper around CDKTF
- Host: GitHub
- URL: https://github.com/iac-factory/cdktf
- Owner: iac-factory
- License: bsd-3-clause
- Created: 2022-06-14T04:12:49.000Z (about 3 years ago)
- Default Branch: Development
- Last Pushed: 2022-06-21T06:16:12.000Z (almost 3 years ago)
- Last Synced: 2025-02-08T17:44:56.535Z (4 months ago)
- Language: TypeScript
- Size: 27.3 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# [`cdktf-factory`](https://github.com/iac-factory/cdktf-factory) #
A functional wrapper for `constructs` & `cdktf`.
## Usage ##
```bash
npm i cdktf-factory
```
### Implementation ###
***Example*** - NPM Deployment Package
```typescript
import * as Path from "path";
import { Stack, Asset, Output, Reader } from "cdktf-factory";
const Name = "files";
const Construct = Stack( Name );
const assets = new Asset( Construct, "node-modules", {
path: "./node_modules",
type: 1
} );
new Output( Construct, "hash", {
value: assets.assetHash
} );
const files = Object.create( {} );
Reader.read( assets.fileName ).forEach( (descriptor) => {
const relative = Path.relative( process.cwd(), descriptor.path );
if ( descriptor.properties.file ) files[ relative ] = {
path: relative,
name: descriptor.name
};
} );
new Output( Construct, "dependencies", {
value: JSON.stringify( files, null, 4 )
} );
Construct.source.synth();
```
***Example*** - Docker
```typescript
import { Stack } from "cdktf-factory";
import { Container, Image, DockerProvider } from "@cdktf/provider-docker";
const Construct = Stack("example");
new DockerProvider(Construct, "docker-provider", {});
const image = new Image(Construct, "nginx-image", {
name: "nginx:latest",
keepLocally: false,
});
new Container(Construct, "nginx-container", {
name: "tutorial",
image: image.latest,
ports: [
{
internal: 80,
external: 8000
},
],
});
/*** npm run synth || npx cdktf@latest -- synth */
Construct.source.synth();
```
## Design Philosophy ##
Using functions vs classes is essentially a religious debate. However, in the
context of IaC, there are a few reasons to elect for functional, prototypal
development.
Take for example a client package: `example-client`. The developer(s) behind `example-client`
want the fastest, easiest means to define their infrastructure, but don't care to
learn straight `terraform` as their package is purely `typescript`.
The first, perhaps most obvious benefit is the use of only a global namespace.
There exists no `class` or `Function` nested namespaces.
I then remove the requirement of using both `IContruct` types: `TerraformStack` and `App`. At first when working
with `cdktf`, I actually experienced some runtime errors when working with more than
a single stack. I also experienced colleagues make the same mistakes.
Additionally, the ability to extend or inherit from `Stack` (at least easily), was removed.
The `Stack` wrapper should only ever be used as an ***interface*** -- e.g. the `Stack` wrapper
is intended to be composed in context, not extended into a namespace.
Lastly, but most importantly, ***I want a means to provide long-term support while
also ensuring of backwards compatability.***
If the client can only initialize `Stack` via ` (input: string) ()`, and the
return type always remains a `IConstruct`, I now have the capability to extend the
`cdktf-factory` context as much as needed. For example, I can add default tags
(not only in the context of `aws`) that then get propagated to all downstream client packages, as well as provide special
terraform backend(s) by default.