terraconstructs 0.1.4 → 0.1.5

package/lib/errors.js

@@ -0,0 +1,215 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.232.2/packages/aws-cdk-lib/core/lib/errors.ts
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ConstructError_time, _ConstructError_constructPath, _ConstructError_constructInfo;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionError = exports.AssumptionError = exports.UnscopedValidationError = exports.ValidationError = exports.Errors = void 0;
+// TODO: check whether Assertion and CloudAssembly errors are needed
+const CONSTRUCT_ERROR_SYMBOL = Symbol.for("terraconstructs/core.SynthesisError");
+const VALIDATION_ERROR_SYMBOL = Symbol.for("terraconstructs/core.ValidationError");
+const ASSUMPTION_ERROR_SYMBOL = Symbol.for("terraconstructs/core.AssumptionError");
+const EXECUTION_ERROR_SYMBOL = Symbol.for("terraconstructs/core.ExecutionError");
+/**
+ * Helper to check if an error is of a certain type.
+ */
+class Errors {
+    /**
+     * Test whether the given errors is a ConstructionError.
+     *
+     * A ConstructionError is a generic error that will be thrown during the App construction or synthesis.
+     * To check for more specific errors, use the respective methods.
+     */
+    static isConstructError(x) {
+        return x !== null && typeof x === "object" && CONSTRUCT_ERROR_SYMBOL in x;
+    }
+    /**
+     * Test whether the given error is a ValidationError.
+     *
+     * A ValidationError is thrown when input props are failing to pass the rules of the construct.
+     * It usually means the underlying CloudFormation resource(s) would not deploy with a given configuration.
+     */
+    static isValidationError(x) {
+        return Errors.isConstructError(x) && VALIDATION_ERROR_SYMBOL in x;
+    }
+    /**
+     * Test whether the given error is an ExecutionError.
+     *
+     * An ExecutionError is thrown if an externally executed script or code failed.
+     */
+    static isExecutionError(x) {
+        return x !== null && typeof x === "object" && EXECUTION_ERROR_SYMBOL in x;
+    }
+    /**
+     * Test whether the given error is an AssumptionError.
+     *
+     * An AssumptionError is thrown when a construct made an assumption somewhere that doesn't hold true.
+     * This error always indicates a bug in the construct.
+     */
+    static isAssumptionError(x) {
+        return x !== null && typeof x === "object" && ASSUMPTION_ERROR_SYMBOL in x;
+    }
+}
+exports.Errors = Errors;
+/**
+ * Generic, abstract error class used for errors thrown from the users app during construction or synth.
+ */
+class ConstructError extends Error {
+    /**
+     * The time the error was thrown.
+     */
+    get time() {
+        return __classPrivateFieldGet(this, _ConstructError_time, "f");
+    }
+    /**
+     * The level. Always `'error'`.
+     */
+    get level() {
+        return "error";
+    }
+    /**
+     * The path of the construct this error is thrown from, if available.
+     */
+    get constructPath() {
+        return __classPrivateFieldGet(this, _ConstructError_constructPath, "f");
+    }
+    /**
+     * Information on the construct this error is thrown from, if available.
+     */
+    get constructInfo() {
+        return __classPrivateFieldGet(this, _ConstructError_constructInfo, "f");
+    }
+    constructor(msg, scope, name) {
+        super(msg);
+        _ConstructError_time.set(this, void 0);
+        _ConstructError_constructPath.set(this, void 0);
+        _ConstructError_constructInfo.set(this, void 0);
+        Object.setPrototypeOf(this, ConstructError.prototype);
+        Object.defineProperty(this, CONSTRUCT_ERROR_SYMBOL, { value: true });
+        this.name = name ?? new.target.name;
+        __classPrivateFieldSet(this, _ConstructError_time, new Date().toISOString(), "f");
+        __classPrivateFieldSet(this, _ConstructError_constructPath, scope?.node.path, "f");
+        if (scope) {
+            Error.captureStackTrace(this, scope.constructor);
+            // TODO: maybe something similar to "constructInfoFromConstruct"
+            __classPrivateFieldSet(this, _ConstructError_constructInfo, undefined, "f");
+        }
+        const stack = [`${this.name}: ${this.message}`];
+        if (this.constructInfo) {
+            stack.push(`in ${this.constructInfo?.fqn} at [${this.constructPath}]`);
+        }
+        else {
+            stack.push(`in [${this.constructPath}]`);
+        }
+        if (this.stack) {
+            stack.push(this.stack);
+        }
+        this.stack = this.constructStack(this.stack);
+    }
+    /**
+     * Helper message to clean-up the stack and amend with construct information.
+     */
+    constructStack(prev) {
+        const indent = " ".repeat(4);
+        const stack = [`${this.name}: ${this.message}`];
+        if (this.constructInfo) {
+            stack.push(`${indent}at path [${this.constructPath}] in ${this.constructInfo?.fqn}`);
+        }
+        else {
+            stack.push(`${indent}at path [${this.constructPath}]`);
+        }
+        if (prev) {
+            stack.push("");
+            stack.push(...prev.split("\n").slice(1));
+        }
+        return stack.join("\n");
+    }
+}
+_ConstructError_time = new WeakMap(), _ConstructError_constructPath = new WeakMap(), _ConstructError_constructInfo = new WeakMap();
+/**
+ * A ValidationError should be used when input props fail to pass the validation rules of a construct
+ * or class or late binding. The error indicates that the underlying CloudFormation resource(s) would
+ * not deploy with a given configuration, or that some other prerequisites are not met.
+ *
+ * A ValidationError is always attached to a Construct scope. To a user, the error will present with additional
+ * information on the construct that caused the validation to fail.
+ *
+ * @internal
+ */
+class ValidationError extends ConstructError {
+    get type() {
+        return "validation";
+    }
+    constructor(msg, scope) {
+        super(msg, scope);
+        Object.setPrototypeOf(this, ValidationError.prototype);
+        Object.defineProperty(this, VALIDATION_ERROR_SYMBOL, { value: true });
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * An UnscopedValidationError is a ValidationError that is not attached to a specific construct.
+ * This can be used to report validation errors that are thrown when no construct scope is available.
+ * The common use case here are data classes that assert on props, but are not constructs itself.
+ *
+ * To a User, these errors still present themselves as a "ValidationError".
+ * However they do not contain any information about the location in the construct tree.
+ *
+ * @internal
+ */
+class UnscopedValidationError extends ConstructError {
+    get type() {
+        return "validation";
+    }
+    constructor(msg) {
+        super(msg, undefined, ValidationError.name);
+        Object.setPrototypeOf(this, UnscopedValidationError.prototype);
+        Object.defineProperty(this, VALIDATION_ERROR_SYMBOL, { value: true });
+    }
+}
+exports.UnscopedValidationError = UnscopedValidationError;
+/**
+ * Some construct code made an assumption somewhere that doesn't hold true
+ *
+ * This error always indicates a bug in the construct.
+ *
+ * @internal
+ */
+class AssumptionError extends ConstructError {
+    get type() {
+        return "assumption";
+    }
+    constructor(msg) {
+        super(msg, undefined, AssumptionError.name);
+        Object.setPrototypeOf(this, AssumptionError.prototype);
+        Object.defineProperty(this, ASSUMPTION_ERROR_SYMBOL, { value: true });
+    }
+}
+exports.AssumptionError = AssumptionError;
+/**
+ * A CDK app may execute external code or shell scripts. If such an execution fails, an ExecutionError is thrown.
+ * The output log and error message will provide more details on the actual failure.
+ *
+ * @internal
+ */
+class ExecutionError extends ConstructError {
+    get type() {
+        return "exec";
+    }
+    constructor(msg) {
+        super(msg, undefined, ExecutionError.name);
+        Object.setPrototypeOf(this, ExecutionError.prototype);
+        Object.defineProperty(this, EXECUTION_ERROR_SYMBOL, { value: true });
+    }
+}
+exports.ExecutionError = ExecutionError;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.232.2/packages/aws-cdk-lib/core/lib/errors.ts\n\nimport type { IConstruct } from \"constructs\";\n\n// TODO: check whether Assertion and CloudAssembly errors are needed\nconst CONSTRUCT_ERROR_SYMBOL = Symbol.for(\n  \"terraconstructs/core.SynthesisError\",\n);\nconst VALIDATION_ERROR_SYMBOL = Symbol.for(\n  \"terraconstructs/core.ValidationError\",\n);\nconst ASSUMPTION_ERROR_SYMBOL = Symbol.for(\n  \"terraconstructs/core.AssumptionError\",\n);\nconst EXECUTION_ERROR_SYMBOL = Symbol.for(\n  \"terraconstructs/core.ExecutionError\",\n);\n\n/**\n * Helper to check if an error is of a certain type.\n */\nexport class Errors {\n  /**\n   * Test whether the given errors is a ConstructionError.\n   *\n   * A ConstructionError is a generic error that will be thrown during the App construction or synthesis.\n   * To check for more specific errors, use the respective methods.\n   */\n  public static isConstructError(x: any): x is ConstructError {\n    return x !== null && typeof x === \"object\" && CONSTRUCT_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Test whether the given error is a ValidationError.\n   *\n   * A ValidationError is thrown when input props are failing to pass the rules of the construct.\n   * It usually means the underlying CloudFormation resource(s) would not deploy with a given configuration.\n   */\n  public static isValidationError(x: any): x is ValidationError {\n    return Errors.isConstructError(x) && VALIDATION_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Test whether the given error is an ExecutionError.\n   *\n   * An ExecutionError is thrown if an externally executed script or code failed.\n   */\n  public static isExecutionError(x: any): x is ExecutionError {\n    return x !== null && typeof x === \"object\" && EXECUTION_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Test whether the given error is an AssumptionError.\n   *\n   * An AssumptionError is thrown when a construct made an assumption somewhere that doesn't hold true.\n   * This error always indicates a bug in the construct.\n   */\n  public static isAssumptionError(x: any): x is AssumptionError {\n    return x !== null && typeof x === \"object\" && ASSUMPTION_ERROR_SYMBOL in x;\n  }\n}\n\ninterface ConstructInfo {\n  readonly fqn: string;\n  readonly version: string;\n}\n\n/**\n * Generic, abstract error class used for errors thrown from the users app during construction or synth.\n */\nabstract class ConstructError extends Error {\n  #time: string;\n  #constructPath?: string;\n  #constructInfo?: ConstructInfo;\n\n  /**\n   * The time the error was thrown.\n   */\n  public get time(): string {\n    return this.#time;\n  }\n\n  /**\n   * The level. Always `'error'`.\n   */\n  public get level(): \"error\" {\n    return \"error\";\n  }\n\n  /**\n   * The type of the error.\n   */\n  public abstract get type(): string;\n\n  /**\n   * The path of the construct this error is thrown from, if available.\n   */\n  public get constructPath(): string | undefined {\n    return this.#constructPath;\n  }\n\n  /**\n   * Information on the construct this error is thrown from, if available.\n   */\n  public get constructInfo(): ConstructInfo | undefined {\n    return this.#constructInfo;\n  }\n\n  constructor(msg: string, scope?: IConstruct, name?: string) {\n    super(msg);\n    Object.setPrototypeOf(this, ConstructError.prototype);\n    Object.defineProperty(this, CONSTRUCT_ERROR_SYMBOL, { value: true });\n\n    this.name = name ?? new.target.name;\n    this.#time = new Date().toISOString();\n    this.#constructPath = scope?.node.path;\n\n    if (scope) {\n      Error.captureStackTrace(this, scope.constructor);\n      // TODO: maybe something similar to \"constructInfoFromConstruct\"\n      this.#constructInfo = undefined;\n    }\n\n    const stack = [`${this.name}: ${this.message}`];\n\n    if (this.constructInfo) {\n      stack.push(`in ${this.constructInfo?.fqn} at [${this.constructPath}]`);\n    } else {\n      stack.push(`in [${this.constructPath}]`);\n    }\n\n    if (this.stack) {\n      stack.push(this.stack);\n    }\n\n    this.stack = this.constructStack(this.stack);\n  }\n\n  /**\n   * Helper message to clean-up the stack and amend with construct information.\n   */\n  private constructStack(prev?: string) {\n    const indent = \" \".repeat(4);\n\n    const stack = [`${this.name}: ${this.message}`];\n\n    if (this.constructInfo) {\n      stack.push(\n        `${indent}at path [${this.constructPath}] in ${this.constructInfo?.fqn}`,\n      );\n    } else {\n      stack.push(`${indent}at path [${this.constructPath}]`);\n    }\n\n    if (prev) {\n      stack.push(\"\");\n      stack.push(...prev.split(\"\\n\").slice(1));\n    }\n\n    return stack.join(\"\\n\");\n  }\n}\n\n/**\n * A ValidationError should be used when input props fail to pass the validation rules of a construct\n * or class or late binding. The error indicates that the underlying CloudFormation resource(s) would\n * not deploy with a given configuration, or that some other prerequisites are not met.\n *\n * A ValidationError is always attached to a Construct scope. To a user, the error will present with additional\n * information on the construct that caused the validation to fail.\n *\n * @internal\n */\nexport class ValidationError extends ConstructError {\n  public get type(): \"validation\" {\n    return \"validation\";\n  }\n\n  constructor(msg: string, scope: IConstruct) {\n    super(msg, scope);\n    Object.setPrototypeOf(this, ValidationError.prototype);\n    Object.defineProperty(this, VALIDATION_ERROR_SYMBOL, { value: true });\n  }\n}\n\n/**\n * An UnscopedValidationError is a ValidationError that is not attached to a specific construct.\n * This can be used to report validation errors that are thrown when no construct scope is available.\n * The common use case here are data classes that assert on props, but are not constructs itself.\n *\n * To a User, these errors still present themselves as a \"ValidationError\".\n * However they do not contain any information about the location in the construct tree.\n *\n * @internal\n */\nexport class UnscopedValidationError extends ConstructError {\n  public get type(): \"validation\" {\n    return \"validation\";\n  }\n\n  constructor(msg: string) {\n    super(msg, undefined, ValidationError.name);\n    Object.setPrototypeOf(this, UnscopedValidationError.prototype);\n    Object.defineProperty(this, VALIDATION_ERROR_SYMBOL, { value: true });\n  }\n}\n\n/**\n * Some construct code made an assumption somewhere that doesn't hold true\n *\n * This error always indicates a bug in the construct.\n *\n * @internal\n */\nexport class AssumptionError extends ConstructError {\n  public get type(): \"assumption\" {\n    return \"assumption\";\n  }\n\n  constructor(msg: string) {\n    super(msg, undefined, AssumptionError.name);\n    Object.setPrototypeOf(this, AssumptionError.prototype);\n    Object.defineProperty(this, ASSUMPTION_ERROR_SYMBOL, { value: true });\n  }\n}\n\n/**\n * A CDK app may execute external code or shell scripts. If such an execution fails, an ExecutionError is thrown.\n * The output log and error message will provide more details on the actual failure.\n *\n * @internal\n */\nexport class ExecutionError extends ConstructError {\n  public get type(): \"exec\" {\n    return \"exec\";\n  }\n\n  constructor(msg: string) {\n    super(msg, undefined, ExecutionError.name);\n    Object.setPrototypeOf(this, ExecutionError.prototype);\n    Object.defineProperty(this, EXECUTION_ERROR_SYMBOL, { value: true });\n  }\n}\n"]}

package/lib/expiration.js

@@ -64,5 +64,5 @@ class Expiration {
 }
 exports.Expiration = Expiration;
 _a = JSII_RTTI_SYMBOL_1;
-Expiration[_a] = { fqn: "terraconstructs.Expiration", version: "0.1.4" };
+Expiration[_a] = { fqn: "terraconstructs.Expiration", version: "0.1.5" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/fs/ignore.js

@@ -64,7 +64,7 @@ class IgnoreStrategy {
 }
 exports.IgnoreStrategy = IgnoreStrategy;
 _a = JSII_RTTI_SYMBOL_1;
-IgnoreStrategy[_a] = { fqn: "terraconstructs.IgnoreStrategy", version: "0.1.4" };
+IgnoreStrategy[_a] = { fqn: "terraconstructs.IgnoreStrategy", version: "0.1.5" };
 /**
  * Ignores file paths based on simple glob patterns.
  */
@@ -114,7 +114,7 @@ class GlobIgnoreStrategy extends IgnoreStrategy {
 }
 exports.GlobIgnoreStrategy = GlobIgnoreStrategy;
 _b = JSII_RTTI_SYMBOL_1;
-GlobIgnoreStrategy[_b] = { fqn: "terraconstructs.GlobIgnoreStrategy", version: "0.1.4" };
+GlobIgnoreStrategy[_b] = { fqn: "terraconstructs.GlobIgnoreStrategy", version: "0.1.5" };
 /**
  * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).
  */
@@ -150,7 +150,7 @@ class GitIgnoreStrategy extends IgnoreStrategy {
 }
 exports.GitIgnoreStrategy = GitIgnoreStrategy;
 _c = JSII_RTTI_SYMBOL_1;
-GitIgnoreStrategy[_c] = { fqn: "terraconstructs.GitIgnoreStrategy", version: "0.1.4" };
+GitIgnoreStrategy[_c] = { fqn: "terraconstructs.GitIgnoreStrategy", version: "0.1.5" };
 /**
  * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).
  */
@@ -186,5 +186,5 @@ class DockerIgnoreStrategy extends IgnoreStrategy {
 }
 exports.DockerIgnoreStrategy = DockerIgnoreStrategy;
 _d = JSII_RTTI_SYMBOL_1;
-DockerIgnoreStrategy[_d] = { fqn: "terraconstructs.DockerIgnoreStrategy", version: "0.1.4" };
+DockerIgnoreStrategy[_d] = { fqn: "terraconstructs.DockerIgnoreStrategy", version: "0.1.5" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ignore.js","sourceRoot":"","sources":["../../src/fs/ignore.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/fs/ignore.ts\n\nimport * as path from \"path\";\nimport dockerIgnore, * as DockerIgnore from \"@balena/dockerignore\";\nimport gitIgnore, * as GitIgnore from \"ignore\";\nimport { CopyOptions, IgnoreMode } from \"./options\";\n\n// Must be a 'require' to not run afoul of ESM module import rules\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst minimatch = require(\"minimatch\");\n\n/**\n * Represents file path ignoring behavior.\n */\nexport abstract class IgnoreStrategy {\n  /**\n   * Ignores file paths based on simple glob patterns.\n   *\n   * @returns `GlobIgnorePattern` associated with the given patterns.\n   * @param absoluteRootPath the absolute path to the root directory of the paths to be considered\n   */\n  public static glob(\n    absoluteRootPath: string,\n    patterns: string[],\n  ): GlobIgnoreStrategy {\n    return new GlobIgnoreStrategy(absoluteRootPath, patterns);\n  }\n\n  /**\n   * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).\n   *\n   * @returns `GitIgnorePattern` associated with the given patterns.\n   * @param absoluteRootPath the absolute path to the root directory of the paths to be considered\n   */\n  public static git(\n    absoluteRootPath: string,\n    patterns: string[],\n  ): GitIgnoreStrategy {\n    return new GitIgnoreStrategy(absoluteRootPath, patterns);\n  }\n\n  /**\n   * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).\n   *\n   * @returns `DockerIgnorePattern` associated with the given patterns.\n   * @param absoluteRootPath the absolute path to the root directory of the paths to be considered\n   */\n  public static docker(\n    absoluteRootPath: string,\n    patterns: string[],\n  ): DockerIgnoreStrategy {\n    return new DockerIgnoreStrategy(absoluteRootPath, patterns);\n  }\n\n  /**\n   * Creates an IgnoreStrategy based on the `ignoreMode` and `exclude` in a `CopyOptions`.\n   *\n   * @returns `IgnoreStrategy` based on the `CopyOptions`\n   * @param absoluteRootPath the absolute path to the root directory of the paths to be considered\n   * @param options the `CopyOptions` to create the `IgnoreStrategy` from\n   */\n  public static fromCopyOptions(\n    options: CopyOptions,\n    absoluteRootPath: string,\n  ): IgnoreStrategy {\n    const ignoreMode = options.ignoreMode || IgnoreMode.GLOB;\n    const exclude = options.exclude || [];\n\n    switch (ignoreMode) {\n      case IgnoreMode.GLOB:\n        return this.glob(absoluteRootPath, exclude);\n\n      case IgnoreMode.GIT:\n        return this.git(absoluteRootPath, exclude);\n\n      case IgnoreMode.DOCKER:\n        return this.docker(absoluteRootPath, exclude);\n    }\n  }\n\n  /**\n   * Adds another pattern.\n   * @params pattern the pattern to add\n   */\n  public abstract add(pattern: string): void;\n\n  /**\n   * Determines whether a given file path should be ignored or not.\n   *\n   * @param absoluteFilePath absolute file path to be assessed against the pattern\n   * @returns `true` if the file should be ignored\n   */\n  public abstract ignores(absoluteFilePath: string): boolean;\n}\n\n/**\n * Ignores file paths based on simple glob patterns.\n */\nexport class GlobIgnoreStrategy extends IgnoreStrategy {\n  private readonly absoluteRootPath: string;\n  private readonly patterns: string[];\n\n  constructor(absoluteRootPath: string, patterns: string[]) {\n    super();\n\n    if (!path.isAbsolute(absoluteRootPath)) {\n      throw new Error(\"GlobIgnoreStrategy expects an absolute file path\");\n    }\n\n    this.absoluteRootPath = absoluteRootPath;\n    this.patterns = patterns;\n  }\n\n  /**\n   * Adds another pattern.\n   * @params pattern the pattern to add\n   */\n  public add(pattern: string): void {\n    this.patterns.push(pattern);\n  }\n\n  /**\n   * Determines whether a given file path should be ignored or not.\n   *\n   * @param absoluteFilePath absolute file path to be assessed against the pattern\n   * @returns `true` if the file should be ignored\n   */\n  public ignores(absoluteFilePath: string): boolean {\n    if (!path.isAbsolute(absoluteFilePath)) {\n      throw new Error(\"GlobIgnoreStrategy.ignores() expects an absolute path\");\n    }\n\n    let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);\n    let excludeOutput = false;\n\n    for (const pattern of this.patterns) {\n      const negate = pattern.startsWith(\"!\");\n      const match = minimatch(relativePath, pattern, {\n        matchBase: true,\n        flipNegate: true,\n      });\n\n      if (!negate && match) {\n        excludeOutput = true;\n      }\n\n      if (negate && match) {\n        excludeOutput = false;\n      }\n    }\n\n    return excludeOutput;\n  }\n}\n\n/**\n * Ignores file paths based on the [`.gitignore specification`](https://git-scm.com/docs/gitignore).\n */\nexport class GitIgnoreStrategy extends IgnoreStrategy {\n  private readonly absoluteRootPath: string;\n  private readonly ignore: GitIgnore.Ignore;\n\n  constructor(absoluteRootPath: string, patterns: string[]) {\n    super();\n\n    if (!path.isAbsolute(absoluteRootPath)) {\n      throw new Error(\"GitIgnoreStrategy expects an absolute file path\");\n    }\n\n    this.absoluteRootPath = absoluteRootPath;\n    this.ignore = gitIgnore().add(patterns);\n  }\n\n  /**\n   * Adds another pattern.\n   * @params pattern the pattern to add\n   */\n  public add(pattern: string): void {\n    this.ignore.add(pattern);\n  }\n\n  /**\n   * Determines whether a given file path should be ignored or not.\n   *\n   * @param absoluteFilePath absolute file path to be assessed against the pattern\n   * @returns `true` if the file should be ignored\n   */\n  public ignores(absoluteFilePath: string): boolean {\n    if (!path.isAbsolute(absoluteFilePath)) {\n      throw new Error(\"GitIgnoreStrategy.ignores() expects an absolute path\");\n    }\n\n    let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);\n\n    return this.ignore.ignores(relativePath);\n  }\n}\n\n/**\n * Ignores file paths based on the [`.dockerignore specification`](https://docs.docker.com/engine/reference/builder/#dockerignore-file).\n */\nexport class DockerIgnoreStrategy extends IgnoreStrategy {\n  private readonly absoluteRootPath: string;\n  private readonly ignore: DockerIgnore.Ignore;\n\n  constructor(absoluteRootPath: string, patterns: string[]) {\n    super();\n\n    if (!path.isAbsolute(absoluteRootPath)) {\n      throw new Error(\"DockerIgnoreStrategy expects an absolute file path\");\n    }\n\n    this.absoluteRootPath = absoluteRootPath;\n    this.ignore = dockerIgnore().add(patterns);\n  }\n\n  /**\n   * Adds another pattern.\n   * @params pattern the pattern to add\n   */\n  public add(pattern: string): void {\n    this.ignore.add(pattern);\n  }\n\n  /**\n   * Determines whether a given file path should be ignored or not.\n   *\n   * @param absoluteFilePath absolute file path to be assessed against the pattern\n   * @returns `true` if the file should be ignored\n   */\n  public ignores(absoluteFilePath: string): boolean {\n    if (!path.isAbsolute(absoluteFilePath)) {\n      throw new Error(\n        \"DockerIgnoreStrategy.ignores() expects an absolute path\",\n      );\n    }\n\n    let relativePath = path.relative(this.absoluteRootPath, absoluteFilePath);\n\n    return this.ignore.ignores(relativePath);\n  }\n}\n"]}

package/lib/fs/index.js

@@ -84,5 +84,5 @@ class FileSystem {
 }
 exports.FileSystem = FileSystem;
 _a = JSII_RTTI_SYMBOL_1;
-FileSystem[_a] = { fqn: "terraconstructs.FileSystem", version: "0.1.4" };
+FileSystem[_a] = { fqn: "terraconstructs.FileSystem", version: "0.1.5" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/size.js

@@ -164,7 +164,7 @@ class Size {
 }
 exports.Size = Size;
 _a = JSII_RTTI_SYMBOL_1;
-Size[_a] = { fqn: "terraconstructs.Size", version: "0.1.4" };
+Size[_a] = { fqn: "terraconstructs.Size", version: "0.1.5" };
 /**
  * Rounding behaviour when converting between units of `Size`.
  */

package/lib/stack-base.js

@@ -165,5 +165,5 @@ class StackBase extends cdktf_1.TerraformStack {
 }
 exports.StackBase = StackBase;
 _a = JSII_RTTI_SYMBOL_1;
-StackBase[_a] = { fqn: "terraconstructs.StackBase", version: "0.1.4" };
+StackBase[_a] = { fqn: "terraconstructs.StackBase", version: "0.1.5" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-base.js","sourceRoot":"","sources":["../src/stack-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { provider as archiveProvider } from \"@cdktf/provider-archive\";\nimport {\n  TerraformStack,\n  TerraformElement,\n  HttpBackendConfig,\n  HttpBackend,\n  Tokenization,\n  DefaultTokenResolver, // https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/resolvable.ts#L176\n  StringConcat, // https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/resolvable.ts#L156\n  Aspects,\n  IResolveContext,\n  Lazy,\n} from \"cdktf\";\nimport { Construct, IConstruct, Node } from \"constructs\";\nimport {\n  makeUniqueResourceName,\n  makeUniqueResourceNamePrefix,\n  TerraformDependencyAspect,\n} from \"./private\";\n\nconst TOKEN_RESOLVER = new DefaultTokenResolver(new StringConcat());\n\nconst TERRASTACK_SYMBOL = Symbol.for(\"terraconstructs/lib.Stack\");\n\n// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/core/lib/names.ts\n\n/**\n * Options for creating a unique resource name_prefix.\n */\nexport interface UniqueResourceNamePrefixOptions\n  extends UniqueResourceNameOptions {\n  /**\n   * Length of the random generated suffix added by some Terraform providers.\n   *\n   * NOTE: https://github.com/hashicorp/terraform-provider-aws/issues/625\n   * @default - 26\n   */\n  readonly suffixLength?: number;\n}\n\n/**\n * Options for creating a unique resource name.\n */\nexport interface UniqueResourceNameOptions {\n  /**\n   * The maximum length of the unique resource name.\n   *\n   * @default - 256\n   */\n  readonly maxLength?: number;\n\n  /**\n   * The separator used between the path components.\n   *\n   * @default - none\n   */\n  readonly separator?: string;\n\n  /**\n   * Non-alphanumeric characters allowed in the unique resource name.\n   *\n   * @default - none\n   */\n  readonly allowedSpecialCharacters?: string;\n\n  /**\n   * Prefix to be added into the stack name\n   *\n   * @default - none\n   */\n  readonly prefix?: string;\n\n  /**\n   * Whether to convert the resource name to lowercase.\n   *\n   * @default - false\n   */\n  readonly lowerCase?: boolean;\n}\n\nexport interface StackBaseProps {\n  /**\n   * TerraConstruct UUID within the grid.\n   *\n   * UUID is generated by the CLI and ensures resource Identity\n   * is decoupled from resource tagging for consistency.\n   *\n   * UUID may be user provided for imported resources\n   */\n  readonly gridUUID: string;\n\n  /**\n   * The environment name passed in from the CLI\n   */\n  readonly environmentName: string;\n\n  /**\n   * Stores the state using a simple REST client.\n   *\n   * State will be fetched via GET, updated via POST, and purged with DELETE.\n   * The method used for updating is configurable.\n   *\n   * This backend optionally supports state locking.\n   * When locking support is enabled it will use LOCK and UNLOCK requests providing the lock info in the body.\n   * The endpoint should return a 423: Locked or 409: Conflict with the holding lock info when\n   * it's already taken, 200: OK for success. Any other status will be considered an error.\n   * The ID of the holding lock info will be added as a query parameter to state updates requests.\n   *\n   * Read more about this backend in the Terraform docs:\n   * https://developer.hashicorp.com/terraform/language/settings/backends/http\n   */\n  readonly gridBackendConfig?: HttpBackendConfig;\n}\n\nexport interface IStack extends IConstruct {\n  /**\n   * Environment Name passed in from the CLI\n   */\n  readonly environmentName: string;\n  readonly gridUUID: string;\n  readonly gridBackend?: HttpBackend;\n  /**\n   * A singleton Archive Provider used to archive assets.\n   * This is used for example for inline Code content in aws Lambda Functions.\n   *\n   * ref: https://github.com/hashicorp/terraform-provider-aws/issues/9774#issuecomment-669356786\n   */\n  readonly archiveProvider: archiveProvider.ArchiveProvider;\n  resolve(obj: any, preparing?: boolean): any;\n  uniqueResourceName(\n    tfElement: TerraformElement | Node,\n    options?: UniqueResourceNameOptions,\n  ): string;\n  uniqueResourceNamePrefix(\n    tfElement: TerraformElement | Node,\n    options?: UniqueResourceNamePrefixOptions,\n  ): string;\n  // toJsonString(obj: any, space?: number): string;\n}\n\n/**\n * Base class for all TerraConstructs stacks\n *\n * Provides a reference to the grid UUID and environment name\n */\nexport abstract class StackBase extends TerraformStack implements IStack {\n  /**\n   * Return whether the given object is a Stack.\n   *\n   * attribute detection since as 'instanceof' potentially fails across Library releases.\n   */\n  public static isTerraStack(x: any): x is IStack {\n    return x !== null && typeof x === \"object\" && TERRASTACK_SYMBOL in x;\n  }\n\n  /**\n   * Looks up the first stack scope in which `construct` is defined. Fails if there is no stack up the tree or the stack is not an IStack.\n   * @param construct The construct to start the search from.\n   */\n  public static ofTerraConstruct(construct: IConstruct): IStack {\n    const s = TerraformStack.of(construct);\n    if (StackBase.isTerraStack(s)) {\n      return s;\n    }\n    throw new Error(\n      `Resource '${construct.constructor?.name}' at '${construct.node.path}' should be created in the scope of TerraConstruct IStack, but no IStack found`,\n    );\n  }\n\n  /**\n   * Returns a unique identifier for a construct based on its path within\n   * a TerraformStack. see uniqueResourceName, but with no separator, maximum length 255 and allows\n   *  \"_\" and \"-\" on top of alphanumerical characters.\n   *\n   * @param construct The construct\n   * @returns a unique resource name based on the construct path\n   */\n  public static uniqueId(construct: IConstruct | Node) {\n    const node = Construct.isConstruct(construct) ? construct.node : construct;\n    const stack = node.scopes\n      .reverse()\n      .find((component) => TerraformStack.isStack(component));\n\n    if (!stack) {\n      throw new Error(\n        \"Unable to calculate a unique id without a stack in the construct path\",\n      );\n    }\n\n    const specIndex = node.scopes.indexOf(stack);\n    const componentsPath = node.scopes\n      .slice(specIndex)\n      .map((component) => component.node.id);\n\n    return makeUniqueResourceName(componentsPath, {\n      maxLength: 255,\n      // avoid https://github.com/aws/aws-cdk/issues/6421\n      allowedSpecialCharacters: \"_-\",\n    });\n  }\n\n  /**\n   * Stack unique grid identifier\n   */\n  public readonly gridUUID: string;\n\n  /**\n   * Environment Name passed in from the CLI\n   */\n  public readonly environmentName: string;\n\n  /**\n   * The grid provided backend for state storage\n   */\n  public readonly gridBackend?: HttpBackend;\n\n  private archiveProviderSingleton?: archiveProvider.ArchiveProvider;\n  public get archiveProvider(): archiveProvider.ArchiveProvider {\n    if (!this.archiveProviderSingleton) {\n      this.archiveProviderSingleton = new archiveProvider.ArchiveProvider(\n        this,\n        \"ArchiveProvider\",\n      );\n    }\n    return this.archiveProviderSingleton;\n  }\n\n  constructor(scope: Construct, id: string, props: StackBaseProps) {\n    super(scope, id);\n    this.gridUUID = props.gridUUID;\n    this.environmentName = props.environmentName;\n    Object.defineProperty(this, TERRASTACK_SYMBOL, { value: true });\n    if (props.gridBackendConfig) {\n      this.gridBackend = new HttpBackend(this, props.gridBackendConfig);\n    }\n\n    // Map construct tree dependencies to ITerraformDependables\n    // ref: https://github.com/hashicorp/terraform-cdk/issues/2727#issuecomment-1473321075\n    Aspects.of(this).add(new TerraformDependencyAspect());\n    // Aspects are invoked in synth after stack has been prepared\n    // this should ensure any resources added during `prepareStack()` are included in the dependency tree\n    // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/synthesize/synthesizer.ts#L121\n  }\n\n  /**\n   * Returns a Terraform-compatible unique identifier for a Terraform Element based\n   * on its path. This function finds the stackName of the parent stack (non-nested)\n   * to the construct, and the ids of the components in the construct path.\n   *\n   * The user can define allowed special characters, a separator between the elements,\n   * and the maximum length of the resource name. The name includes a human readable portion rendered\n   * from the path components, with or without user defined separators, and a hash suffix.\n   * If the resource name is longer than the maximum length, it is trimmed in the middle.\n   *\n   * @param tfElement The construct\n   * @param options Options for defining the unique resource name\n   * @returns a unique resource name based on the construct path\n   */\n  public uniqueResourceName(\n    tfElement: TerraformElement | Node,\n    options: UniqueResourceNameOptions = {},\n  ): string {\n    const node = Construct.isConstruct(tfElement) ? tfElement.node : tfElement;\n    const stack = TerraformElement.isTerraformElement(tfElement)\n      ? tfElement.cdktfStack\n      : this;\n    const stackIndex = node.scopes.indexOf(stack);\n    const componentsPath = node.scopes\n      .slice(stackIndex)\n      .map((component) => component.node.id);\n\n    return makeUniqueResourceName(componentsPath, options);\n  }\n\n  /**\n   * Returns a Terraform-compatible unique identifier for a Terraform Element based\n   * on its path. This function finds the stackName of the parent stack (non-nested)\n   * to the construct, and the ids of the components in the construct path.\n   *\n   * The user can define allowed special characters, a separator between the elements,\n   * and the maximum length of the resource name. The name includes a human readable portion rendered\n   * from the path components, with or without user defined separators, and depends on the\n   * resource provider to generate the random suffix.\n   *\n   * If the resource name is longer than the maximum length - suffixLength, it is trimmed in the middle.\n   *\n   * @param tfElement The construct\n   * @param options Options for defining the unique resource name\n   * @returns a unique resource name based on the construct path\n   */\n  public uniqueResourceNamePrefix(\n    tfElement: TerraformElement | Node,\n    options: UniqueResourceNamePrefixOptions = {},\n  ): string {\n    const node = Construct.isConstruct(tfElement) ? tfElement.node : tfElement;\n    const stack = TerraformElement.isTerraformElement(tfElement)\n      ? tfElement.cdktfStack\n      : this;\n    const stackIndex = node.scopes.indexOf(stack);\n    const componentsPath = node.scopes\n      .slice(stackIndex)\n      .map((component) => component.node.id);\n\n    return makeUniqueResourceNamePrefix(componentsPath, options);\n  }\n\n  /** Resolve IResolvable in scope of this AwsStack */\n  public resolve(obj: any, preparing = false): any {\n    return Tokenization.resolve(obj, {\n      scope: this,\n      preparing,\n      resolver: TOKEN_RESOLVER,\n    });\n  }\n\n  /**\n   * Convert an object, potentially containing tokens, to a JSON string\n   */\n  public toJsonString(obj: any, space?: number): string {\n    return Lazy.stringValue({\n      produce: (ctx: IResolveContext) => {\n        // First resolve Token objects with string concat... then JSON.stringify the resulting object\n        //\n        // unlike cloudformation, Terraform does not need an intrinsic wrapper?\n        // https://github.com/aws/aws-cdk/blob/8dca5079e1893122057f9e2c54c0da0ba644926e/packages/%40aws-cdk/core/lib/private/cloudformation-lang.ts#L73\n        // intrinsic wrapper without cross stack ref\n        // https://github.com/aws/aws-cdk/blob/14e4bc91ed5f0f8cb7c8ac9ee8a6de4da54e6585/packages/%40aws-cdk/core/lib/private/cloudformation-lang.ts#L50\n        const resolved = Tokenization.resolve(obj, {\n          preparing: ctx.preparing,\n          scope: ctx.scope,\n          resolver: TOKEN_RESOLVER,\n        });\n        return JSON.stringify(resolved, undefined, space);\n      },\n    });\n  }\n}\n"]}

package/lib/terra-func.js

@@ -159,7 +159,7 @@ class Fn extends cdktf_1.Fn {
 }
 exports.Fn = Fn;
 _a = JSII_RTTI_SYMBOL_1;
-Fn[_a] = { fqn: "terraconstructs.Fn", version: "0.1.4" };
+Fn[_a] = { fqn: "terraconstructs.Fn", version: "0.1.5" };
 function range(n) {
     const ret = [];
     for (let i = 0; i < n; i++) {

package/lib/time-zone.js

@@ -29,7 +29,7 @@ class TimeZone {
 }
 exports.TimeZone = TimeZone;
 _a = JSII_RTTI_SYMBOL_1;
-TimeZone[_a] = { fqn: "terraconstructs.TimeZone", version: "0.1.4" };
+TimeZone[_a] = { fqn: "terraconstructs.TimeZone", version: "0.1.5" };
 /** IANA Time Zone database entry for Africa/Abidjan.  UTC offset +00:00/+00:00. */
 TimeZone.AFRICA_ABIDJAN = new TimeZone("Africa/Abidjan");
 /** IANA Time Zone database entry for Africa/Algiers.  UTC offset +01:00/+01:00. */

package/package.json

@@ -82,7 +82,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.4",
+  "version": "0.1.5",
   "jest": {
     "coverageProvider": "v8",
     "setupFilesAfterEnv": [