terraconstructs 0.0.8

package/lib/aws/compute/index.d.ts

@@ -0,0 +1,42 @@
+export * from "./event-source-filter";
+export * from "./event-source-mapping";
+export * from "./event-invoke-config";
+export * from "./function-base";
+export * from "./function";
+export * from "./function-alias";
+export * from "./function-destination";
+export * from "./function-nodejs";
+export * from "./function-permission";
+export * from "./function-url";
+export * from "./architecture";
+export * from "./fields";
+export * from "./activity";
+export * from "./task-input";
+export * from "./types";
+export * from "./condition";
+export * from "./state-machine";
+export * from "./state-machine-fragment";
+export * from "./chain";
+export * from "./state-graph";
+export * from "./step-functions-task";
+export * from "./states/choice";
+export * from "./states/fail";
+export * from "./states/parallel";
+export * from "./states/pass";
+export * from "./states/state";
+export * from "./states/succeed";
+export * from "./states/task";
+export * from "./states/wait";
+export * from "./states/map";
+export * from "./states/distributed-map";
+export * from "./states/distributed-map/item-batcher";
+export * from "./states/distributed-map/item-reader";
+export * from "./states/distributed-map/result-writer";
+export * from "./states/custom-state";
+export * from "./states/map-base";
+export * from "./states/task-base";
+export * from "./task-credentials";
+export * as sources from "./event-sources";
+export * as destinations from "./function-destinations";
+export * as tasks from "./tasks";
+export * from "./function-vpc-config.generated";

package/lib/aws/compute/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tasks = exports.destinations = exports.sources = void 0;
+__exportStar(require("./event-source-filter"), exports);
+__exportStar(require("./event-source-mapping"), exports);
+__exportStar(require("./event-invoke-config"), exports);
+__exportStar(require("./function-base"), exports);
+__exportStar(require("./function"), exports);
+__exportStar(require("./function-alias"), exports);
+__exportStar(require("./function-destination"), exports);
+__exportStar(require("./function-nodejs"), exports);
+__exportStar(require("./function-permission"), exports);
+__exportStar(require("./function-url"), exports);
+__exportStar(require("./architecture"), exports);
+// stepfunctions
+__exportStar(require("./fields"), exports);
+__exportStar(require("./activity"), exports);
+__exportStar(require("./task-input"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./condition"), exports);
+__exportStar(require("./state-machine"), exports);
+__exportStar(require("./state-machine-fragment"), exports);
+// TODO: When re-adding, make sure to also add test/state-transition-metrics.test.ts
+// export * from "./state-transition-metrics";
+__exportStar(require("./chain"), exports);
+__exportStar(require("./state-graph"), exports);
+__exportStar(require("./step-functions-task"), exports);
+__exportStar(require("./states/choice"), exports);
+__exportStar(require("./states/fail"), exports);
+__exportStar(require("./states/parallel"), exports);
+__exportStar(require("./states/pass"), exports);
+__exportStar(require("./states/state"), exports);
+__exportStar(require("./states/succeed"), exports);
+__exportStar(require("./states/task"), exports);
+__exportStar(require("./states/wait"), exports);
+__exportStar(require("./states/map"), exports);
+__exportStar(require("./states/distributed-map"), exports);
+__exportStar(require("./states/distributed-map/item-batcher"), exports);
+__exportStar(require("./states/distributed-map/item-reader"), exports);
+__exportStar(require("./states/distributed-map/result-writer"), exports);
+__exportStar(require("./states/custom-state"), exports);
+__exportStar(require("./states/map-base"), exports);
+__exportStar(require("./states/task-base"), exports);
+__exportStar(require("./task-credentials"), exports);
+exports.sources = require("./event-sources");
+exports.destinations = require("./function-destinations");
+exports.tasks = require("./tasks"); // State Machine Tasks
+// generated by JSII Struct builder to please JSII pacman
+__exportStar(require("./function-vpc-config.generated"), exports);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/private/intrinstics.d.ts

@@ -0,0 +1,86 @@
+export type IntrinsicExpression = StringLiteralExpression | PathExpression | FnCallExpression;
+export type TopLevelIntrinsic = PathExpression | FnCallExpression;
+export interface StringLiteralExpression {
+    readonly type: "string-literal";
+    readonly literal: string;
+}
+export interface PathExpression {
+    readonly type: "path";
+    readonly path: string;
+}
+export interface FnCallExpression {
+    readonly type: "fncall";
+    readonly functionName: string;
+    readonly arguments: IntrinsicExpression[];
+}
+/**
+ * LL(1) parser for StepFunctions intrinsics
+ *
+ * The parser implements a state machine over a cursor into an expression
+ * string. The cusor gets moved, the character at the cursor gets inspected
+ * and based on the character we accumulate some value and potentially move
+ * to a different state.
+ *
+ * Literal strings are not allowed at the top level, but are allowed inside
+ * function calls.
+ */
+export declare class IntrinsicParser {
+    private readonly expression;
+    private i;
+    constructor(expression: string);
+    parseTopLevelIntrinsic(): TopLevelIntrinsic;
+    private parseIntrinsic;
+    /**
+     * Simplified path parsing
+     *
+     * JSON path can actually be quite complicated, but we don't need to validate
+     * it precisely. We just need to know how far it extends.
+     *
+     * Therefore, we only care about:
+     *
+     * - Starts with a $
+     * - Accept ., $ and alphanums
+     * - Accept single-quoted strings ('...')
+     * - Accept anything between matched square brackets ([...])
+     */
+    private parsePath;
+    /**
+     * Parse a fncall
+     *
+     * Cursor should be on call identifier. Afterwards, cursor will be on closing
+     * quote.
+     */
+    private parseFnCall;
+    /**
+     * Parse a string literal
+     *
+     * Cursor is expected to be on the first opening quote. Afterwards,
+     * cursor will be after the closing quote.
+     */
+    private parseStringLiteral;
+    /**
+     * Parse a bracketed expression
+     *
+     * Cursor is expected to be on the opening brace. Afterwards,
+     * the cursor will be after the closing brace.
+     */
+    private consumeBracketedExpression;
+    /**
+     * Parse a string literal
+     *
+     * Cursor is expected to be on the first opening quote. Afterwards,
+     * cursor will be after the closing quote.
+     */
+    private consumeQuotedString;
+    /**
+     * Consume whitespace if it exists
+     *
+     * Move the cursor to the next non-whitespace character.
+     */
+    private ws;
+    private get eof();
+    private char;
+    private next;
+    private consume;
+    private raiseError;
+}

package/lib/aws/compute/private/intrinstics.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntrinsicParser = void 0;
+/**
+ * LL(1) parser for StepFunctions intrinsics
+ *
+ * The parser implements a state machine over a cursor into an expression
+ * string. The cusor gets moved, the character at the cursor gets inspected
+ * and based on the character we accumulate some value and potentially move
+ * to a different state.
+ *
+ * Literal strings are not allowed at the top level, but are allowed inside
+ * function calls.
+ */
+class IntrinsicParser {
+    constructor(expression) {
+        this.expression = expression;
+        this.i = 0;
+    }
+    parseTopLevelIntrinsic() {
+        this.ws();
+        let ret;
+        if (this.char() === "$") {
+            ret = this.parsePath();
+        }
+        else if (isAlphaNum(this.char())) {
+            ret = this.parseFnCall();
+        }
+        else {
+            this.raiseError("expected '$' or a function call");
+        }
+        this.ws();
+        if (!this.eof) {
+            this.raiseError("unexpected trailing characters");
+        }
+        return ret;
+    }
+    parseIntrinsic() {
+        this.ws();
+        if (this.char() === "$") {
+            return this.parsePath();
+        }
+        if (isAlphaNum(this.char())) {
+            return this.parseFnCall();
+        }
+        if (this.char() === "'") {
+            return this.parseStringLiteral();
+        }
+        this.raiseError("expected $, function or single-quoted string");
+    }
+    /**
+     * Simplified path parsing
+     *
+     * JSON path can actually be quite complicated, but we don't need to validate
+     * it precisely. We just need to know how far it extends.
+     *
+     * Therefore, we only care about:
+     *
+     * - Starts with a $
+     * - Accept ., $ and alphanums
+     * - Accept single-quoted strings ('...')
+     * - Accept anything between matched square brackets ([...])
+     */
+    parsePath() {
+        const pathString = new Array();
+        if (this.char() !== "$") {
+            this.raiseError("expected '$'");
+        }
+        pathString.push(this.consume());
+        let done = false;
+        while (!done && !this.eof) {
+            switch (this.char()) {
+                case ".":
+                case "$":
+                    pathString.push(this.consume());
+                    break;
+                case "'":
+                    const { quoted } = this.consumeQuotedString();
+                    pathString.push(quoted);
+                    break;
+                case "[":
+                    pathString.push(this.consumeBracketedExpression("]"));
+                    break;
+                default:
+                    if (isAlphaNum(this.char())) {
+                        pathString.push(this.consume());
+                        break;
+                    }
+                    // Not alphanum, end of path expression
+                    done = true;
+            }
+        }
+        return { type: "path", path: pathString.join("") };
+    }
+    /**
+     * Parse a fncall
+     *
+     * Cursor should be on call identifier. Afterwards, cursor will be on closing
+     * quote.
+     */
+    parseFnCall() {
+        const name = new Array();
+        while (this.char() !== "(") {
+            name.push(this.consume());
+        }
+        this.next(); // Consume the '('
+        this.ws();
+        const args = [];
+        while (this.char() !== ")") {
+            args.push(this.parseIntrinsic());
+            this.ws();
+            if (this.char() === ",") {
+                this.next();
+                continue;
+            }
+            else if (this.char() === ")") {
+                continue;
+            }
+            else {
+                this.raiseError("expected , or )");
+            }
+        }
+        this.next(); // Consume ')'
+        return {
+            type: "fncall",
+            arguments: args,
+            functionName: name.join(""),
+        };
+    }
+    /**
+     * Parse a string literal
+     *
+     * Cursor is expected to be on the first opening quote. Afterwards,
+     * cursor will be after the closing quote.
+     */
+    parseStringLiteral() {
+        const { unquoted } = this.consumeQuotedString();
+        return { type: "string-literal", literal: unquoted };
+    }
+    /**
+     * Parse a bracketed expression
+     *
+     * Cursor is expected to be on the opening brace. Afterwards,
+     * the cursor will be after the closing brace.
+     */
+    consumeBracketedExpression(closingBrace) {
+        const ret = new Array();
+        ret.push(this.consume());
+        while (this.char() !== closingBrace) {
+            if (this.char() === "[") {
+                ret.push(this.consumeBracketedExpression("]"));
+            }
+            else if (this.char() === "{") {
+                ret.push(this.consumeBracketedExpression("}"));
+            }
+            else {
+                ret.push(this.consume());
+            }
+        }
+        ret.push(this.consume());
+        return ret.join("");
+    }
+    /**
+     * Parse a string literal
+     *
+     * Cursor is expected to be on the first opening quote. Afterwards,
+     * cursor will be after the closing quote.
+     */
+    consumeQuotedString() {
+        const quoted = new Array();
+        const unquoted = new Array();
+        quoted.push(this.consume());
+        while (this.char() !== "'") {
+            if (this.char() === "\\") {
+                // Advance and add next character literally, whatever it is
+                quoted.push(this.consume());
+            }
+            quoted.push(this.char());
+            unquoted.push(this.char());
+            this.next();
+        }
+        quoted.push(this.consume());
+        return { quoted: quoted.join(""), unquoted: unquoted.join("") };
+    }
+    /**
+     * Consume whitespace if it exists
+     *
+     * Move the cursor to the next non-whitespace character.
+     */
+    ws() {
+        while (!this.eof && [" ", "\t", "\n"].includes(this.char())) {
+            this.next();
+        }
+    }
+    get eof() {
+        return this.i >= this.expression.length;
+    }
+    char() {
+        if (this.eof) {
+            this.raiseError("unexpected end of string");
+        }
+        return this.expression[this.i];
+    }
+    next() {
+        this.i++;
+    }
+    consume() {
+        const ret = this.char();
+        this.next();
+        return ret;
+    }
+    raiseError(message) {
+        throw new Error(`Invalid JSONPath expression: ${message} at index ${this.i} in ${JSON.stringify(this.expression)}`);
+    }
+}
+exports.IntrinsicParser = IntrinsicParser;
+function isAlphaNum(x) {
+    return x.match(/^[a-zA-Z0-9]$/);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intrinstics.js","sourceRoot":"","sources":["../../../../src/aws/compute/private/intrinstics.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/private/intrinstics.ts\nexport type IntrinsicExpression =\n  | StringLiteralExpression\n  | PathExpression\n  | FnCallExpression;\nexport type TopLevelIntrinsic = PathExpression | FnCallExpression;\n\nexport interface StringLiteralExpression {\n  readonly type: \"string-literal\";\n  readonly literal: string;\n}\n\nexport interface PathExpression {\n  readonly type: \"path\";\n  readonly path: string;\n}\n\nexport interface FnCallExpression {\n  readonly type: \"fncall\";\n  readonly functionName: string;\n  readonly arguments: IntrinsicExpression[];\n}\n\n/**\n * LL(1) parser for StepFunctions intrinsics\n *\n * The parser implements a state machine over a cursor into an expression\n * string. The cusor gets moved, the character at the cursor gets inspected\n * and based on the character we accumulate some value and potentially move\n * to a different state.\n *\n * Literal strings are not allowed at the top level, but are allowed inside\n * function calls.\n */\nexport class IntrinsicParser {\n  private i: number = 0;\n\n  constructor(private readonly expression: string) {}\n\n  public parseTopLevelIntrinsic(): TopLevelIntrinsic {\n    this.ws();\n\n    let ret;\n    if (this.char() === \"$\") {\n      ret = this.parsePath();\n    } else if (isAlphaNum(this.char())) {\n      ret = this.parseFnCall();\n    } else {\n      this.raiseError(\"expected '$' or a function call\");\n    }\n\n    this.ws();\n\n    if (!this.eof) {\n      this.raiseError(\"unexpected trailing characters\");\n    }\n\n    return ret;\n  }\n\n  private parseIntrinsic(): IntrinsicExpression {\n    this.ws();\n\n    if (this.char() === \"$\") {\n      return this.parsePath();\n    }\n\n    if (isAlphaNum(this.char())) {\n      return this.parseFnCall();\n    }\n\n    if (this.char() === \"'\") {\n      return this.parseStringLiteral();\n    }\n\n    this.raiseError(\"expected $, function or single-quoted string\");\n  }\n\n  /**\n   * Simplified path parsing\n   *\n   * JSON path can actually be quite complicated, but we don't need to validate\n   * it precisely. We just need to know how far it extends.\n   *\n   * Therefore, we only care about:\n   *\n   * - Starts with a $\n   * - Accept ., $ and alphanums\n   * - Accept single-quoted strings ('...')\n   * - Accept anything between matched square brackets ([...])\n   */\n  private parsePath(): PathExpression {\n    const pathString = new Array<string>();\n    if (this.char() !== \"$\") {\n      this.raiseError(\"expected '$'\");\n    }\n    pathString.push(this.consume());\n\n    let done = false;\n    while (!done && !this.eof) {\n      switch (this.char()) {\n        case \".\":\n        case \"$\":\n          pathString.push(this.consume());\n          break;\n        case \"'\":\n          const { quoted } = this.consumeQuotedString();\n          pathString.push(quoted);\n          break;\n\n        case \"[\":\n          pathString.push(this.consumeBracketedExpression(\"]\"));\n          break;\n\n        default:\n          if (isAlphaNum(this.char())) {\n            pathString.push(this.consume());\n            break;\n          }\n\n          // Not alphanum, end of path expression\n          done = true;\n      }\n    }\n\n    return { type: \"path\", path: pathString.join(\"\") };\n  }\n\n  /**\n   * Parse a fncall\n   *\n   * Cursor should be on call identifier. Afterwards, cursor will be on closing\n   * quote.\n   */\n  private parseFnCall(): FnCallExpression {\n    const name = new Array<string>();\n    while (this.char() !== \"(\") {\n      name.push(this.consume());\n    }\n\n    this.next(); // Consume the '('\n    this.ws();\n\n    const args = [];\n    while (this.char() !== \")\") {\n      args.push(this.parseIntrinsic());\n      this.ws();\n\n      if (this.char() === \",\") {\n        this.next();\n        continue;\n      } else if (this.char() === \")\") {\n        continue;\n      } else {\n        this.raiseError(\"expected , or )\");\n      }\n    }\n    this.next(); // Consume ')'\n\n    return {\n      type: \"fncall\",\n      arguments: args,\n      functionName: name.join(\"\"),\n    };\n  }\n\n  /**\n   * Parse a string literal\n   *\n   * Cursor is expected to be on the first opening quote. Afterwards,\n   * cursor will be after the closing quote.\n   */\n  private parseStringLiteral(): StringLiteralExpression {\n    const { unquoted } = this.consumeQuotedString();\n    return { type: \"string-literal\", literal: unquoted };\n  }\n\n  /**\n   * Parse a bracketed expression\n   *\n   * Cursor is expected to be on the opening brace. Afterwards,\n   * the cursor will be after the closing brace.\n   */\n  private consumeBracketedExpression(closingBrace: string): string {\n    const ret = new Array<string>();\n    ret.push(this.consume());\n    while (this.char() !== closingBrace) {\n      if (this.char() === \"[\") {\n        ret.push(this.consumeBracketedExpression(\"]\"));\n      } else if (this.char() === \"{\") {\n        ret.push(this.consumeBracketedExpression(\"}\"));\n      } else {\n        ret.push(this.consume());\n      }\n    }\n    ret.push(this.consume());\n    return ret.join(\"\");\n  }\n\n  /**\n   * Parse a string literal\n   *\n   * Cursor is expected to be on the first opening quote. Afterwards,\n   * cursor will be after the closing quote.\n   */\n  private consumeQuotedString(): { readonly quoted: string; unquoted: string } {\n    const quoted = new Array<string>();\n    const unquoted = new Array<string>();\n\n    quoted.push(this.consume());\n    while (this.char() !== \"'\") {\n      if (this.char() === \"\\\\\") {\n        // Advance and add next character literally, whatever it is\n        quoted.push(this.consume());\n      }\n      quoted.push(this.char());\n      unquoted.push(this.char());\n      this.next();\n    }\n    quoted.push(this.consume());\n    return { quoted: quoted.join(\"\"), unquoted: unquoted.join(\"\") };\n  }\n\n  /**\n   * Consume whitespace if it exists\n   *\n   * Move the cursor to the next non-whitespace character.\n   */\n  private ws() {\n    while (!this.eof && [\" \", \"\\t\", \"\\n\"].includes(this.char())) {\n      this.next();\n    }\n  }\n\n  private get eof() {\n    return this.i >= this.expression.length;\n  }\n\n  private char(): string {\n    if (this.eof) {\n      this.raiseError(\"unexpected end of string\");\n    }\n\n    return this.expression[this.i];\n  }\n\n  private next() {\n    this.i++;\n  }\n\n  private consume() {\n    const ret = this.char();\n    this.next();\n    return ret;\n  }\n\n  private raiseError(message: string): never {\n    throw new Error(\n      `Invalid JSONPath expression: ${message} at index ${this.i} in ${JSON.stringify(this.expression)}`,\n    );\n  }\n}\n\nfunction isAlphaNum(x: string) {\n  return x.match(/^[a-zA-Z0-9]$/);\n}\n"]}

package/lib/aws/compute/private/json-path.d.ts

@@ -0,0 +1,57 @@
+import { IResolvable, IResolveContext } from "cdktf";
+export declare class JsonPathToken implements IResolvable {
+    readonly path: string;
+    static isJsonPathToken(x: IResolvable): x is JsonPathToken;
+    readonly creationStack: string[];
+    displayHint: string;
+    constructor(path: string);
+    resolve(_ctx: IResolveContext): any;
+    toString(): string;
+    toJSON(): string;
+}
+/**
+ * Deep render a JSON object to expand JSON path fields, updating the key to end in '.$'
+ */
+export declare function renderObject(obj: object | undefined): object | undefined;
+/**
+ * Return all JSON paths that are used in the given structure
+ */
+export declare function findReferencedPaths(obj: object | undefined): Set<string>;
+interface FieldHandlers {
+    handleString(key: string, x: string): {
+        [key: string]: string;
+    };
+    handleList(key: string, x: string[]): {
+        [key: string]: string[] | string;
+    };
+    handleNumber(key: string, x: number): {
+        [key: string]: number | string;
+    };
+    handleBoolean(key: string, x: boolean): {
+        [key: string]: boolean;
+    };
+    handleResolvable(key: string, x: IResolvable): {
+        [key: string]: any;
+    };
+}
+export declare function recurseObject(obj: object | undefined, handlers: FieldHandlers, visited?: object[]): object | undefined;
+/**
+ * If the indicated string is an encoded JSON path, return the path
+ *
+ * Otherwise return undefined.
+ */
+export declare function jsonPathString(x: string): string | undefined;
+export declare function jsonPathFromAny(x: any): string | undefined;
+/**
+ * Render the string or number value in a valid JSON Path expression.
+ *
+ * If the value is a Tokenized JSON path reference -- return the JSON path reference inside it.
+ * If the value is a number -- convert it to string.
+ * If the value is a string -- single-quote it.
+ * Otherwise, throw errors.
+ *
+ * Call this function whenever you're building compound JSONPath expressions, in
+ * order to avoid having tokens-in-tokens-in-tokens which become very hard to parse.
+ */
+export declare function renderInExpression(x: any): string;
+export {};