tessl/npm-cdktf

Cloud Development Kit for Terraform - programmatic infrastructure as code using familiar programming languages

Overview

Eval results

Files

CDKTF - Cloud Development Kit for Terraform

Name: tessl/npm-cdktf
Author: tessl

The Cloud Development Kit for Terraform (CDKTF) enables you to define cloud infrastructure using familiar programming languages instead of HashiCorp Configuration Language (HCL). It leverages the entire Terraform ecosystem through a TypeScript-based JSII library that supports multiple target languages including Python, Java, C#, and Go.

Package Information

Package Name: cdktf
Package Type: npm
Language: TypeScript (with JSII multi-language support)
Installation: npm install cdktf constructs

Core Imports

import { App, TerraformStack, TerraformOutput } from "cdktf";
import { Construct } from "constructs";

For CommonJS:

const { App, TerraformStack, TerraformOutput } = require("cdktf");

Basic Usage

import { App, TerraformStack, TerraformOutput } from "cdktf";
import { Construct } from "constructs";

class MyStack extends TerraformStack {
  constructor(scope: Construct, id: string) {
    super(scope, id);

    // Add Terraform resources, data sources, and outputs here
    new TerraformOutput(this, "example", {
      value: "Hello, CDKTF!",
    });
  }
}

const app = new App();
new MyStack(app, "my-stack");
app.synth();

Architecture

CDKTF is built around several key architectural components:

Constructs Framework: Based on AWS CDK constructs, providing a hierarchical component model
JSII Compatibility: Cross-language support enabling usage in TypeScript, Python, Java, C#, and Go
Terraform Synthesis: Converts construct trees into valid Terraform JSON and HCL configurations
Provider Integration: Seamless integration with the entire Terraform provider ecosystem
State Management: Full compatibility with Terraform state management and backends
Testing Framework: Built-in testing utilities for infrastructure validation

Capabilities

Core Infrastructure Components

Essential classes for building CDKTF applications, including the root App construct and TerraformStack containers.

class App extends Construct {
  constructor(config?: AppConfig);
  synth(): void;
  crossStackReference(fromStack: TerraformStack, toStack: TerraformStack, identifier: string): string;
  static isApp(x: any): x is App;
  static of(construct: IConstruct): App;
}

class TerraformStack extends Construct {
  constructor(scope: Construct, id: string);
  toTerraform(): any;
  toHclTerraform(): any;
  addOverride(path: string, value: any): void;
  getLogicalId(tfElement: ITerraformAddressable): string;
  prepareStack(): void;
  runAllValidations(): void;
  ensureBackendExists(): TerraformBackend;
  allProviders(): TerraformProvider[];
  addDependency(dependency: TerraformStack): void;
  dependsOn(stack: TerraformStack): boolean;
  hasResourceMove(): boolean;
  registerOutgoingCrossStackReference(identifier: string): TerraformOutput;
  registerIncomingCrossStackReference(fromStack: TerraformStack): TerraformRemoteState;
  static isStack(x: any): x is TerraformStack;
  static of(construct: IConstruct): TerraformStack;
}

Core Infrastructure

Resources and Data Sources

Terraform resource and data source management with full attribute access and lifecycle controls.

class TerraformResource extends TerraformElement {
  constructor(scope: Construct, id: string, config: TerraformResourceConfig);
  getStringAttribute(terraformAttribute: string): string;
  getNumberAttribute(terraformAttribute: string): number;
  getListAttribute(terraformAttribute: string): string[];
  getBooleanAttribute(terraformAttribute: string): IResolvable;
  getNumberListAttribute(terraformAttribute: string): number[];
  getStringMapAttribute(terraformAttribute: string): {[key: string]: string};
  getNumberMapAttribute(terraformAttribute: string): {[key: string]: number};
  getBooleanMapAttribute(terraformAttribute: string): {[key: string]: boolean};
  getAnyMapAttribute(terraformAttribute: string): {[key: string]: any};
  interpolationForAttribute(terraformAttribute: string): IResolvable;
  importFrom(id: string, provider?: TerraformProvider): void;
  moveTo(moveTarget: string, index?: string | number): void;
  moveToId(id: string): void;
  moveFromId(id: string): void;
  addMoveTarget(moveTarget: string): void;
  hasResourceMove(): boolean;
  static isTerraformResource(x: any): x is TerraformResource;
}

class TerraformDataSource extends TerraformElement {
  constructor(scope: Construct, id: string, config: TerraformResourceConfig);
  static isTerraformDataSource(x: any): x is TerraformDataSource;
}

Resources and Data Sources

Providers and Modules

Provider configuration and Terraform module integration for external resource management.

abstract class TerraformProvider extends TerraformElement {
  constructor(scope: Construct, id: string, config: TerraformProviderConfig);
  readonly terraformResourceType: string;
  readonly alias?: string;
  static isTerraformProvider(x: any): x is TerraformProvider;
}

abstract class TerraformModule extends TerraformElement {
  constructor(scope: Construct, id: string, options: TerraformModuleConfig);
  interpolationForOutput(moduleOutput: string): IResolvable;
  getString(output: string): string;
  addProvider(provider: TerraformProvider | TerraformModuleProvider): void;
}

Providers and Modules

Variables and Outputs

Input variables and output values for parameterizing and exposing infrastructure values.

class TerraformVariable extends TerraformElement {
  constructor(scope: Construct, id: string, config: TerraformVariableConfig);
  readonly stringValue: string;
  readonly numberValue: number;
  readonly listValue: string[];
  readonly booleanValue: IResolvable;
  readonly value: any;
  addValidation(validation: TerraformVariableValidationConfig): void;
}

class TerraformOutput extends TerraformElement {
  constructor(scope: Construct, id: string, config: TerraformOutputConfig);
  readonly value: any;
  readonly description?: string;
  readonly sensitive?: boolean;
  static isTerraformOutput(x: any): x is TerraformOutput;
}

class TerraformLocal extends TerraformElement {
  constructor(scope: Construct, id: string, expression: any);
  readonly expression: any;
  readonly fqn: string;
}

Variables and Outputs

Backend Configuration

Terraform backend configuration for state management across different storage systems.

abstract class TerraformBackend extends TerraformElement {
  constructor(scope: Construct, id: string, name: string);
  abstract getRemoteStateDataSource(scope: Construct, name: string, fromStack: string): TerraformRemoteState;
  static isBackend(x: any): x is TerraformBackend;
}

Backend implementations: S3Backend, LocalBackend, RemoteBackend, CloudBackend, AzurermBackend, ConsulBackend, GcsBackend, and more.

Backend Configuration

Token System and Expressions

Token resolution system for handling unresolved values and creating Terraform expressions.

class Token {
  static isUnresolved(obj: any): boolean;
  static asString(value: any, options?: EncodingOptions): string;
  static asNumber(value: any): number;
  static asList(value: any, options?: EncodingOptions): string[];
  static asNumberList(value: any): number[];
  static asStringMap(value: any, options?: EncodingOptions): {[key: string]: string};
  static asNumberMap(value: any, options?: EncodingOptions): {[key: string]: number};
  static asBooleanMap(value: any, options?: EncodingOptions): {[key: string]: boolean};
  static asAnyMap(value: any, options?: EncodingOptions): {[key: string]: any};
  static asAny(value: any): IResolvable;
  static nullValue(): IResolvable;
}

function ref(identifier: string, stack?: TerraformStack): IResolvable;
function conditional(condition: Expression, trueValue: Expression, falseValue: Expression): any;
function propertyAccess(target: Expression, args: Expression[]): IResolvable;

Token System and Expressions

Iterators and Dynamic Blocks

Iterator support for for_each constructs and dynamic block generation.

abstract class TerraformIterator {
  static fromList(list: any[]): ListTerraformIterator;
  static fromMap(map: {[key: string]: any}): MapTerraformIterator;
  static fromResources(resource: ITerraformResource): ResourceTerraformIterator;
  getString(attribute: string): string;
  getNumber(attribute: string): number;
  dynamic(attributes: {[key: string]: any}): IResolvable;
  keys(): IResolvable;
  values(): IResolvable;
}

Iterators and Dynamic Blocks

Terraform Functions

Comprehensive access to Terraform's built-in functions for expressions and computations.

class Fn {
  static bcrypt(str: string, cost?: number): string;
  static conditional(condition: any, trueValue: any, falseValue: any): any;
  static lookup(inputMap: any, key: string, defaultValue?: any): any;
  static join(separator: string, list: string[]): string;
  static length(value: any): number;
  static keys(inputMap: any): string[];
  static values(inputMap: any): any[];
  // Plus 100+ additional Terraform functions
}

Terraform Functions

Testing Framework

Built-in testing utilities for validating CDKTF applications and infrastructure configurations.

class Testing {
  static app(options?: TestingAppConfig): App;
  static stubVersion(app: App): App;
  static fakeCdktfJsonPath(app: App): App;
  static enableFutureFlags(app: App): App;
  static synthScope(fn: IScopeCallback): string;
  static synth(stack: TerraformStack, runValidations?: boolean): string;
  static synthHcl(stack: TerraformStack, runValidations?: boolean, returnMetadata?: boolean): string;
  static fullSynth(stack: TerraformStack): string;
  static renderConstructTree(construct: IConstruct): string;
  static toHaveDataSourceWithProperties(received: string, resourceType: string, properties?: Record<string, any>): boolean;
  static toHaveDataSource(received: string, resourceType: string): boolean;
  static toHaveResourceWithProperties(received: string, resourceType: string, properties?: Record<string, any>): boolean;
  static toHaveResource(received: string, resourceType: string): boolean;
  static toHaveProviderWithProperties(received: string, resourceType: string, properties?: Record<string, any>): boolean;
  static toHaveProvider(received: string, resourceType: string): boolean;
  static toBeValidTerraform(received: string): boolean;
  static setupJest(): void;
}

Testing matchers: toHaveResource, toHaveResourceWithProperties, toHaveDataSource, toBeValidTerraform, and more.

Testing Framework

Provisioners

Resource provisioning capabilities for executing scripts and transferring files during resource creation.

interface FileProvisioner {
  type: "file";
  source: string;
  destination: string;
  connection?: SSHProvisionerConnection | WinrmProvisionerConnection;
}

interface LocalExecProvisioner {
  type: "local-exec";
  command: string;
  workingDir?: string;
  interpreter?: string[];
  environment?: {[key: string]: string};
}

interface RemoteExecProvisioner {
  type: "remote-exec";
  inline?: string[];
  script?: string;
  scripts?: string[];
  connection: SSHProvisionerConnection | WinrmProvisionerConnection;
}

Provisioners

Annotations and Aspects

Construct annotation system for adding metadata and cross-cutting concerns through aspect-oriented programming.

class Annotations {
  static of(scope: IConstruct): Annotations;
  addInfo(message: string): void;
  addWarning(message: string): void;
  addError(message: string): void;
}

interface IAspect {
  visit(node: IConstruct): void;
}

class Aspects {
  static of(scope: IConstruct): Aspects;
  add(aspect: IAspect): void;
  readonly all: IAspect[];
}

Annotations and Aspects

Core Types

interface AppConfig {
  readonly context?: {[key: string]: any};
  readonly outdir?: string;
  readonly stackTraces?: boolean;
  readonly hclOutput?: boolean;
  readonly skipBackendValidation?: boolean;
  readonly skipValidation?: boolean;
}

interface TerraformResourceConfig {
  readonly terraformResourceType: string;
  readonly terraformGeneratorMetadata?: TerraformProviderGeneratorMetadata;
  readonly provider?: TerraformProvider;
  readonly dependsOn?: ITerraformDependable[];
  readonly count?: number | TerraformCount;
  readonly forEach?: ITerraformIterator;
  readonly lifecycle?: TerraformResourceLifecycle;
  readonly provisioners?: (FileProvisioner | LocalExecProvisioner | RemoteExecProvisioner)[];
  readonly connection?: SSHProvisionerConnection | WinrmProvisionerConnection;
}

interface IResolvable {
  readonly creationStack: string[];
  resolve(context: IResolveContext): any;
  toString(): string;
}

interface ITerraformDependable {
  // Marker interface for dependable resources
}

interface ITerraformAddressable {
  readonly fqn: string;
}

interface TestingAppConfig {
  readonly outdir?: string;
  readonly stackTraces?: boolean;
  readonly stubVersion?: boolean;
  readonly enableFutureFlags?: boolean;
  readonly fakeCdktfJsonPath?: boolean;
  readonly context?: {[key: string]: any};
}

interface IScopeCallback {
  (scope: Construct): void;
}

interface EncodingOptions {
  readonly displayHint?: string;
}

Install with Tessl CLI