terraconstructs 0.0.8

package/lib/aws/compute/private/json-path.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderInExpression = exports.jsonPathFromAny = exports.jsonPathString = exports.recurseObject = exports.findReferencedPaths = exports.renderObject = exports.JsonPathToken = void 0;
+// https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-stepfunctions/lib/private/json-path.ts
+const cdktf_1 = require("cdktf");
+const intrinstics_1 = require("./intrinstics");
+const JSON_PATH_TOKEN_SYMBOL = Symbol.for("terraconstructs/lib/aws/compute.JsonPathToken");
+class JsonPathToken {
+    static isJsonPathToken(x) {
+        return x[JSON_PATH_TOKEN_SYMBOL] === true;
+    }
+    constructor(path) {
+        this.path = path;
+        // TODO: Implement stack traces
+        // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9
+        // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22
+        this.creationStack = ["stack traces disabled"];
+        this.displayHint = path.replace(/^[^a-zA-Z]+/, "");
+        Object.defineProperty(this, JSON_PATH_TOKEN_SYMBOL, { value: true });
+    }
+    resolve(_ctx) {
+        return this.path;
+    }
+    toString() {
+        return cdktf_1.Token.asString(this, { displayHint: this.displayHint });
+    }
+    toJSON() {
+        return `<path:${this.path}>`;
+    }
+}
+exports.JsonPathToken = JsonPathToken;
+/**
+ * Deep render a JSON object to expand JSON path fields, updating the key to end in '.$'
+ */
+function renderObject(obj) {
+    return recurseObject(obj, {
+        handleString: renderString,
+        handleList: renderStringList,
+        handleNumber: renderNumber,
+        handleBoolean: renderBoolean,
+        handleResolvable: renderResolvable,
+    });
+}
+exports.renderObject = renderObject;
+/**
+ * Return all JSON paths that are used in the given structure
+ */
+function findReferencedPaths(obj) {
+    const found = new Set();
+    recurseObject(obj, {
+        handleString(_key, x) {
+            for (const p of findPathsInIntrinsicFunctions(jsonPathString(x))) {
+                found.add(p);
+            }
+            return {};
+        },
+        handleList(_key, x) {
+            for (const p of findPathsInIntrinsicFunctions(jsonPathStringList(x))) {
+                found.add(p);
+            }
+            return {};
+        },
+        handleNumber(_key, x) {
+            for (const p of findPathsInIntrinsicFunctions(jsonPathNumber(x))) {
+                found.add(p);
+            }
+            return {};
+        },
+        handleBoolean(_key, _x) {
+            return {};
+        },
+        handleResolvable(_key, x) {
+            for (const p of findPathsInIntrinsicFunctions(jsonPathFromAny(x))) {
+                found.add(p);
+            }
+            return {};
+        },
+    });
+    return found;
+}
+exports.findReferencedPaths = findReferencedPaths;
+/**
+ * From an expression, return the list of JSON paths referenced in it
+ */
+function findPathsInIntrinsicFunctions(expression) {
+    if (!expression) {
+        return [];
+    }
+    const ret = new Array();
+    try {
+        const parsed = new intrinstics_1.IntrinsicParser(expression).parseTopLevelIntrinsic();
+        recurse(parsed);
+        return ret;
+    }
+    catch {
+        // Not sure that our parsing is 100% correct. We don't want to break anyone, so
+        // fall back to legacy behavior if we can't parse this string.
+        return [expression];
+    }
+    function recurse(p) {
+        switch (p.type) {
+            case "path":
+                ret.push(p.path);
+                break;
+            case "fncall":
+                for (const arg of p.arguments) {
+                    recurse(arg);
+                }
+        }
+    }
+}
+function recurseObject(obj, handlers, visited = []) {
+    // If the argument received is not actually an object (string, number, boolean, undefined, ...) or null
+    // just return it as is as there's nothing to be rendered. This should only happen in the original call to
+    // recurseObject as any recursive calls to it are checking for typeof value === 'object' && value !== null
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    // Avoiding infinite recursion
+    if (visited.includes(obj)) {
+        return {};
+    }
+    // Marking current object as visited for the current recursion path
+    visited.push(obj);
+    const ret = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === "string") {
+            Object.assign(ret, handlers.handleString(key, value));
+        }
+        else if (typeof value === "number") {
+            Object.assign(ret, handlers.handleNumber(key, value));
+        }
+        else if (Array.isArray(value)) {
+            Object.assign(ret, recurseArray(key, value, handlers, visited));
+        }
+        else if (typeof value === "boolean") {
+            Object.assign(ret, handlers.handleBoolean(key, value));
+        }
+        else if (value === null || value === undefined) {
+            // Nothing
+        }
+        else if (typeof value === "object") {
+            if (cdktf_1.Tokenization.isResolvable(value)) {
+                Object.assign(ret, handlers.handleResolvable(key, value));
+            }
+            else {
+                ret[key] = recurseObject(value, handlers, visited);
+            }
+        }
+    }
+    // Removing from visited after leaving the current recursion path
+    // Allowing it to be visited again if it's not causing a recursion (circular reference)
+    visited.pop();
+    return ret;
+}
+exports.recurseObject = recurseObject;
+/**
+ * Render an array that may or may not contain a string list token
+ */
+function recurseArray(key, arr, handlers, visited = []) {
+    if (isStringArray(arr)) {
+        const path = jsonPathStringList(arr);
+        if (path !== undefined) {
+            return handlers.handleList(key, arr);
+        }
+        // Fall through to correctly reject encoded strings inside an array.
+        // They cannot be represented because there is no key to append a '.$' to.
+    }
+    return {
+        [key]: resolveArray(arr, handlers, visited),
+    };
+}
+function resolveArray(arr, handlers, visited = []) {
+    return arr.map((value) => {
+        if ((typeof value === "string" && jsonPathString(value) !== undefined) ||
+            (typeof value === "number" && jsonPathNumber(value) !== undefined) ||
+            (isStringArray(value) && jsonPathStringList(value) !== undefined)) {
+            throw new Error("Cannot use JsonPath fields in an array, they must be used in objects");
+        }
+        if (Array.isArray(value)) {
+            return resolveArray(value, handlers, visited);
+        }
+        if (typeof value === "object" && value !== null) {
+            return recurseObject(value, handlers, visited);
+        }
+        return value;
+    });
+}
+function isStringArray(x) {
+    return Array.isArray(x) && x.every((el) => typeof el === "string");
+}
+/**
+ * Render a parameter string
+ *
+ * If the string value starts with '$.', render it as a path string, otherwise as a direct string.
+ */
+function renderString(key, value) {
+    const path = jsonPathString(value);
+    if (path !== undefined) {
+        return { [key + ".$"]: path };
+    }
+    else {
+        return { [key]: value };
+    }
+}
+/**
+ * Render a resolvable
+ *
+ * If we can extract a Path from it, render as a path string, otherwise as itself (will
+ * be resolved later
+ */
+function renderResolvable(key, value) {
+    const path = jsonPathFromAny(value);
+    if (path !== undefined) {
+        return { [key + ".$"]: path };
+    }
+    else {
+        return { [key]: value };
+    }
+}
+/**
+ * Render a parameter string list
+ *
+ * If the string value starts with '$.', render it as a path string, otherwise as a direct string.
+ */
+function renderStringList(key, value) {
+    const path = jsonPathStringList(value);
+    if (path !== undefined) {
+        return { [key + ".$"]: path };
+    }
+    else {
+        return { [key]: value };
+    }
+}
+/**
+ * Render a parameter number
+ *
+ * If the string value starts with '$.', render it as a path string, otherwise as a direct string.
+ */
+function renderNumber(key, value) {
+    const path = jsonPathNumber(value);
+    if (path !== undefined) {
+        return { [key + ".$"]: path };
+    }
+    else {
+        return { [key]: value };
+    }
+}
+/**
+ * Render a parameter boolean
+ */
+function renderBoolean(key, value) {
+    return { [key]: value };
+}
+/**
+ * If the indicated string is an encoded JSON path, return the path
+ *
+ * Otherwise return undefined.
+ */
+function jsonPathString(x) {
+    const fragments = cdktf_1.Tokenization.reverseString(x);
+    const jsonPathTokens = fragments.tokens.filter(JsonPathToken.isJsonPathToken);
+    if (jsonPathTokens.length > 0 && fragments.length > 1) {
+        throw new Error(`Field references must be the entire string, cannot concatenate them (found '${x}')`);
+    }
+    if (jsonPathTokens.length > 0) {
+        return jsonPathTokens[0].path;
+    }
+    return undefined;
+}
+exports.jsonPathString = jsonPathString;
+function jsonPathFromAny(x) {
+    if (!x) {
+        return undefined;
+    }
+    if (typeof x === "string") {
+        return jsonPathString(x);
+    }
+    const resolvables = cdktf_1.Tokenization.reverse(x);
+    if (resolvables.length === 1) {
+        return pathFromToken(resolvables[0]);
+    }
+    if (resolvables.length > 1) {
+        // TODO: Should never happen, but if it does, we should throw a better error
+        throw new Error(`Unexpected value: ${x} (expected a string or a single resolvable)`);
+    }
+    return undefined;
+}
+exports.jsonPathFromAny = jsonPathFromAny;
+/**
+ * If the indicated string list is an encoded JSON path, return the path
+ *
+ * Otherwise return undefined.
+ */
+function jsonPathStringList(x) {
+    return pathFromToken(cdktf_1.Tokenization.reverseList(x));
+}
+/**
+ * If the indicated number is an encoded JSON path, return the path
+ *
+ * Otherwise return undefined.
+ */
+function jsonPathNumber(x) {
+    return pathFromToken(cdktf_1.Tokenization.reverseNumber(x));
+}
+function pathFromToken(token) {
+    return (token && (JsonPathToken.isJsonPathToken(token) ? token.path : 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.
+ */
+function renderInExpression(x) {
+    const path = jsonPathFromAny(x);
+    if (path)
+        return path;
+    if (typeof x === "number")
+        return x.toString(10);
+    if (typeof x === "string")
+        return singleQuotestring(x);
+    throw new Error("Unxexpected value.");
+}
+exports.renderInExpression = renderInExpression;
+function singleQuotestring(x) {
+    const ret = new Array();
+    ret.push("'");
+    for (let i = 0; i < x.length; i++) {
+        const c = x[i];
+        if (c === "'") {
+            ret.push("\\'");
+        }
+        else if (c === "\\" &&
+            (i == x.length - 1 || (x[i + 1] != "{" && x[i + 1] != "}"))) {
+            // Escape backslash, but only if it doesn't immediately precede a curly brace
+            ret.push("\\\\");
+        }
+        else {
+            ret.push(c);
+        }
+    }
+    ret.push("'");
+    return ret.join("");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-path.js","sourceRoot":"","sources":["../../../../src/aws/compute/private/json-path.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/json-path.ts\nimport { Token, IResolvable, IResolveContext, Tokenization } from \"cdktf\";\nimport { IntrinsicParser, IntrinsicExpression } from \"./intrinstics\";\n\nconst JSON_PATH_TOKEN_SYMBOL = Symbol.for(\n  \"terraconstructs/lib/aws/compute.JsonPathToken\",\n);\n\nexport class JsonPathToken implements IResolvable {\n  public static isJsonPathToken(x: IResolvable): x is JsonPathToken {\n    return (x as any)[JSON_PATH_TOKEN_SYMBOL] === true;\n  }\n\n  public readonly creationStack: string[];\n  public displayHint: string;\n\n  constructor(public readonly path: string) {\n    // TODO: Implement stack traces\n    // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9\n    // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22\n    this.creationStack = [\"stack traces disabled\"];\n    this.displayHint = path.replace(/^[^a-zA-Z]+/, \"\");\n    Object.defineProperty(this, JSON_PATH_TOKEN_SYMBOL, { value: true });\n  }\n\n  public resolve(_ctx: IResolveContext): any {\n    return this.path;\n  }\n\n  public toString() {\n    return Token.asString(this, { displayHint: this.displayHint });\n  }\n\n  public toJSON() {\n    return `<path:${this.path}>`;\n  }\n}\n\n/**\n * Deep render a JSON object to expand JSON path fields, updating the key to end in '.$'\n */\nexport function renderObject(obj: object | undefined): object | undefined {\n  return recurseObject(obj, {\n    handleString: renderString,\n    handleList: renderStringList,\n    handleNumber: renderNumber,\n    handleBoolean: renderBoolean,\n    handleResolvable: renderResolvable,\n  });\n}\n\n/**\n * Return all JSON paths that are used in the given structure\n */\nexport function findReferencedPaths(obj: object | undefined): Set<string> {\n  const found = new Set<string>();\n\n  recurseObject(obj, {\n    handleString(_key: string, x: string) {\n      for (const p of findPathsInIntrinsicFunctions(jsonPathString(x))) {\n        found.add(p);\n      }\n      return {};\n    },\n\n    handleList(_key: string, x: string[]) {\n      for (const p of findPathsInIntrinsicFunctions(jsonPathStringList(x))) {\n        found.add(p);\n      }\n      return {};\n    },\n\n    handleNumber(_key: string, x: number) {\n      for (const p of findPathsInIntrinsicFunctions(jsonPathNumber(x))) {\n        found.add(p);\n      }\n      return {};\n    },\n\n    handleBoolean(_key: string, _x: boolean) {\n      return {};\n    },\n\n    handleResolvable(_key: string, x: IResolvable) {\n      for (const p of findPathsInIntrinsicFunctions(jsonPathFromAny(x))) {\n        found.add(p);\n      }\n      return {};\n    },\n  });\n\n  return found;\n}\n\n/**\n * From an expression, return the list of JSON paths referenced in it\n */\nfunction findPathsInIntrinsicFunctions(expression?: string): string[] {\n  if (!expression) {\n    return [];\n  }\n\n  const ret = new Array<string>();\n\n  try {\n    const parsed = new IntrinsicParser(expression).parseTopLevelIntrinsic();\n    recurse(parsed);\n    return ret;\n  } catch {\n    // Not sure that our parsing is 100% correct. We don't want to break anyone, so\n    // fall back to legacy behavior if we can't parse this string.\n    return [expression];\n  }\n\n  function recurse(p: IntrinsicExpression) {\n    switch (p.type) {\n      case \"path\":\n        ret.push(p.path);\n        break;\n\n      case \"fncall\":\n        for (const arg of p.arguments) {\n          recurse(arg);\n        }\n    }\n  }\n}\n\ninterface FieldHandlers {\n  handleString(key: string, x: string): { [key: string]: string };\n  handleList(key: string, x: string[]): { [key: string]: string[] | string };\n  handleNumber(key: string, x: number): { [key: string]: number | string };\n  handleBoolean(key: string, x: boolean): { [key: string]: boolean };\n  handleResolvable(key: string, x: IResolvable): { [key: string]: any };\n}\n\nexport function recurseObject(\n  obj: object | undefined,\n  handlers: FieldHandlers,\n  visited: object[] = [],\n): object | undefined {\n  // If the argument received is not actually an object (string, number, boolean, undefined, ...) or null\n  // just return it as is as there's nothing to be rendered. This should only happen in the original call to\n  // recurseObject as any recursive calls to it are checking for typeof value === 'object' && value !== null\n  if (typeof obj !== \"object\" || obj === null) {\n    return obj;\n  }\n\n  // Avoiding infinite recursion\n  if (visited.includes(obj)) {\n    return {};\n  }\n\n  // Marking current object as visited for the current recursion path\n  visited.push(obj);\n\n  const ret: any = {};\n  for (const [key, value] of Object.entries(obj)) {\n    if (typeof value === \"string\") {\n      Object.assign(ret, handlers.handleString(key, value));\n    } else if (typeof value === \"number\") {\n      Object.assign(ret, handlers.handleNumber(key, value));\n    } else if (Array.isArray(value)) {\n      Object.assign(ret, recurseArray(key, value, handlers, visited));\n    } else if (typeof value === \"boolean\") {\n      Object.assign(ret, handlers.handleBoolean(key, value));\n    } else if (value === null || value === undefined) {\n      // Nothing\n    } else if (typeof value === \"object\") {\n      if (Tokenization.isResolvable(value)) {\n        Object.assign(ret, handlers.handleResolvable(key, value));\n      } else {\n        ret[key] = recurseObject(value, handlers, visited);\n      }\n    }\n  }\n\n  // Removing from visited after leaving the current recursion path\n  // Allowing it to be visited again if it's not causing a recursion (circular reference)\n  visited.pop();\n\n  return ret;\n}\n\n/**\n * Render an array that may or may not contain a string list token\n */\nfunction recurseArray(\n  key: string,\n  arr: any[],\n  handlers: FieldHandlers,\n  visited: object[] = [],\n): { [key: string]: any[] | string } {\n  if (isStringArray(arr)) {\n    const path = jsonPathStringList(arr);\n    if (path !== undefined) {\n      return handlers.handleList(key, arr);\n    }\n\n    // Fall through to correctly reject encoded strings inside an array.\n    // They cannot be represented because there is no key to append a '.$' to.\n  }\n\n  return {\n    [key]: resolveArray(arr, handlers, visited),\n  };\n}\n\nfunction resolveArray(\n  arr: any[],\n  handlers: FieldHandlers,\n  visited: object[] = [],\n): any[] {\n  return arr.map((value) => {\n    if (\n      (typeof value === \"string\" && jsonPathString(value) !== undefined) ||\n      (typeof value === \"number\" && jsonPathNumber(value) !== undefined) ||\n      (isStringArray(value) && jsonPathStringList(value) !== undefined)\n    ) {\n      throw new Error(\n        \"Cannot use JsonPath fields in an array, they must be used in objects\",\n      );\n    }\n    if (Array.isArray(value)) {\n      return resolveArray(value, handlers, visited);\n    }\n    if (typeof value === \"object\" && value !== null) {\n      return recurseObject(value, handlers, visited);\n    }\n    return value;\n  });\n}\n\nfunction isStringArray(x: any): x is string[] {\n  return Array.isArray(x) && x.every((el) => typeof el === \"string\");\n}\n\n/**\n * Render a parameter string\n *\n * If the string value starts with '$.', render it as a path string, otherwise as a direct string.\n */\nfunction renderString(key: string, value: string): { [key: string]: string } {\n  const path = jsonPathString(value);\n  if (path !== undefined) {\n    return { [key + \".$\"]: path };\n  } else {\n    return { [key]: value };\n  }\n}\n\n/**\n * Render a resolvable\n *\n * If we can extract a Path from it, render as a path string, otherwise as itself (will\n * be resolved later\n */\nfunction renderResolvable(\n  key: string,\n  value: IResolvable,\n): { [key: string]: any } {\n  const path = jsonPathFromAny(value);\n  if (path !== undefined) {\n    return { [key + \".$\"]: path };\n  } else {\n    return { [key]: value };\n  }\n}\n\n/**\n * Render a parameter string list\n *\n * If the string value starts with '$.', render it as a path string, otherwise as a direct string.\n */\nfunction renderStringList(\n  key: string,\n  value: string[],\n): { [key: string]: string[] | string } {\n  const path = jsonPathStringList(value);\n  if (path !== undefined) {\n    return { [key + \".$\"]: path };\n  } else {\n    return { [key]: value };\n  }\n}\n\n/**\n * Render a parameter number\n *\n * If the string value starts with '$.', render it as a path string, otherwise as a direct string.\n */\nfunction renderNumber(\n  key: string,\n  value: number,\n): { [key: string]: number | string } {\n  const path = jsonPathNumber(value);\n  if (path !== undefined) {\n    return { [key + \".$\"]: path };\n  } else {\n    return { [key]: value };\n  }\n}\n\n/**\n * Render a parameter boolean\n */\nfunction renderBoolean(\n  key: string,\n  value: boolean,\n): { [key: string]: boolean } {\n  return { [key]: value };\n}\n\n/**\n * If the indicated string is an encoded JSON path, return the path\n *\n * Otherwise return undefined.\n */\nexport function jsonPathString(x: string): string | undefined {\n  const fragments = Tokenization.reverseString(x);\n  const jsonPathTokens = fragments.tokens.filter(JsonPathToken.isJsonPathToken);\n\n  if (jsonPathTokens.length > 0 && fragments.length > 1) {\n    throw new Error(\n      `Field references must be the entire string, cannot concatenate them (found '${x}')`,\n    );\n  }\n  if (jsonPathTokens.length > 0) {\n    return jsonPathTokens[0].path;\n  }\n  return undefined;\n}\n\nexport function jsonPathFromAny(x: any) {\n  if (!x) {\n    return undefined;\n  }\n  if (typeof x === \"string\") {\n    return jsonPathString(x);\n  }\n  const resolvables = Tokenization.reverse(x);\n  if (resolvables.length === 1) {\n    return pathFromToken(resolvables[0]);\n  }\n  if (resolvables.length > 1) {\n    // TODO: Should never happen, but if it does, we should throw a better error\n    throw new Error(\n      `Unexpected value: ${x} (expected a string or a single resolvable)`,\n    );\n  }\n  return undefined;\n}\n\n/**\n * If the indicated string list is an encoded JSON path, return the path\n *\n * Otherwise return undefined.\n */\nfunction jsonPathStringList(x: string[]): string | undefined {\n  return pathFromToken(Tokenization.reverseList(x));\n}\n\n/**\n * If the indicated number is an encoded JSON path, return the path\n *\n * Otherwise return undefined.\n */\nfunction jsonPathNumber(x: number): string | undefined {\n  return pathFromToken(Tokenization.reverseNumber(x));\n}\n\nfunction pathFromToken(token: IResolvable | undefined) {\n  return (\n    token && (JsonPathToken.isJsonPathToken(token) ? token.path : undefined)\n  );\n}\n\n/**\n * Render the string or number value in a valid JSON Path expression.\n *\n * If the value is a Tokenized JSON path reference -- return the JSON path reference inside it.\n * If the value is a number -- convert it to string.\n * If the value is a string -- single-quote it.\n * Otherwise, throw errors.\n *\n * Call this function whenever you're building compound JSONPath expressions, in\n * order to avoid having tokens-in-tokens-in-tokens which become very hard to parse.\n */\nexport function renderInExpression(x: any) {\n  const path = jsonPathFromAny(x);\n  if (path) return path;\n  if (typeof x === \"number\") return x.toString(10);\n  if (typeof x === \"string\") return singleQuotestring(x);\n  throw new Error(\"Unxexpected value.\");\n}\n\nfunction singleQuotestring(x: string) {\n  const ret = new Array<string>();\n  ret.push(\"'\");\n  for (let i = 0; i < x.length; i++) {\n    const c = x[i];\n    if (c === \"'\") {\n      ret.push(\"\\\\'\");\n    } else if (\n      c === \"\\\\\" &&\n      (i == x.length - 1 || (x[i + 1] != \"{\" && x[i + 1] != \"}\"))\n    ) {\n      // Escape backslash, but only if it doesn't immediately precede a curly brace\n      ret.push(\"\\\\\\\\\");\n    } else {\n      ret.push(c);\n    }\n  }\n  ret.push(\"'\");\n  return ret.join(\"\");\n}\n"]}

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

@@ -0,0 +1 @@
+export declare function noEmptyObject<A>(o: Record<string, A>): Record<string, A> | undefined;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noEmptyObject = void 0;
+function noEmptyObject(o) {
+    if (Object.keys(o).length === 0) {
+        return undefined;
+    }
+    return o;
+}
+exports.noEmptyObject = noEmptyObject;
+// import { AwsOwnedEncryptionConfiguration } from "../aws-owned-key-encryption-configuration";
+// import { CustomerManagedEncryptionConfiguration } from "../customer-managed-key-encryption-configuration";
+// import { EncryptionConfiguration } from "../encryption-configuration";
+// export function buildEncryptionConfiguration(
+//   encryptionConfiguration?: EncryptionConfiguration,
+// ) {
+//   if (encryptionConfiguration instanceof AwsOwnedEncryptionConfiguration) {
+//     return {
+//       type: encryptionConfiguration.type,
+//     };
+//   }
+//   if (
+//     encryptionConfiguration instanceof CustomerManagedEncryptionConfiguration
+//   ) {
+//     // Default value for `kmsDataKeyReusePeriodSeconds`, see: https://docs.aws.amazon.com/step-functions/latest/dg/encryption-at-rest.html#cfn-resources-for-encryption-configuration
+//     const DEFAULT_KMS_DATA_KEY_REUSE_PERIOD_SECONDS = 300;
+//     return {
+//       kmsKeyId: encryptionConfiguration.kmsKey.keyArn,
+//       kmsDataKeyReusePeriodSeconds:
+//         encryptionConfiguration.kmsDataKeyReusePeriodSeconds
+//           ? encryptionConfiguration.kmsDataKeyReusePeriodSeconds.toSeconds()
+//           : DEFAULT_KMS_DATA_KEY_REUSE_PERIOD_SECONDS,
+//       type: encryptionConfiguration.type,
+//     };
+//   }
+//   return undefined;
+// }
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/state-graph.d.ts

@@ -0,0 +1,100 @@
+import { StateMachine } from "./state-machine";
+import { Duration } from "../..";
+import * as iam from "../iam";
+import { State } from "./states/state";
+/**
+ * A collection of connected states
+ *
+ * A StateGraph is used to keep track of all states that are connected (have
+ * transitions between them). It does not include the substatemachines in
+ * a Parallel's branches: those are their own StateGraphs, but the graphs
+ * themselves have a hierarchical relationship as well.
+ *
+ * By assigning states to a definitive StateGraph, we verify that no state
+ * machines are constructed. In particular:
+ *
+ * - Every state object can only ever be in 1 StateGraph, and not inadvertently
+ *   be used in two graphs.
+ * - Every stateId must be unique across all states in the entire state
+ *   machine.
+ *
+ * All policy statements in all states in all substatemachines are bubbled so
+ * that the top-level StateMachine instantiation can read them all and add
+ * them to the IAM Role.
+ *
+ * You do not need to instantiate this class; it is used internally.
+ */
+export declare class StateGraph {
+    readonly startState: State;
+    private readonly graphDescription;
+    /**
+     * Set a timeout to render into the graph JSON.
+     *
+     * Read/write. Only makes sense on the top-level graph, subgraphs
+     * do not support this feature.
+     *
+     * @default No timeout
+     */
+    timeout?: Duration;
+    /**
+     * The accumulated policy statements
+     */
+    readonly policyStatements: iam.PolicyStatement[];
+    /**
+     * All states in this graph
+     */
+    private readonly allStates;
+    /**
+     * A mapping of stateId -> Graph for all states in this graph and subgraphs
+     */
+    private readonly allContainedStates;
+    /**
+     * Containing graph of this graph
+     */
+    private superGraph?;
+    /**
+     * @param startState state that gets executed when the state machine is launched
+     * @param graphDescription description of the state machine
+     */
+    constructor(startState: State, graphDescription: string);
+    /**
+     * Register a state as part of this graph
+     *
+     * Called by State.bindToGraph().
+     */
+    registerState(state: State): void;
+    /**
+     * Register a Policy Statement used by states in this graph
+     */
+    registerPolicyStatement(statement: iam.PolicyStatement): void;
+    /**
+     * Register this graph as a child of the given graph
+     *
+     * Resource changes will be bubbled up to the given graph.
+     */
+    registerSuperGraph(graph: StateGraph): void;
+    /**
+     * Return the Amazon States Language JSON for this graph
+     */
+    toGraphJson(): object;
+    /**
+     * Return a string description of this graph
+     */
+    toString(): string;
+    /**
+     * Register a stateId and graph where it was registered
+     */
+    private registerContainedState;
+    /**
+     * Push all contained state info up to the given super graph
+     */
+    private pushContainedStatesUp;
+    /**
+     * Push all policy statements to into the given super graph
+     */
+    private pushPolicyStatementsUp;
+    /**
+     * Binds this StateGraph to the StateMachine it defines and updates state machine permissions
+     */
+    bind(stateMachine: StateMachine): void;
+}