terraconstructs 0.0.24 → 0.1.0

package/lib/aws/compute/resource.js

@@ -0,0 +1,316 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyResource = exports.Resource = exports.ResourceBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cors_1 = require("./cors");
+const integrations_1 = require("./integrations");
+const method_1 = require("./method");
+const restapi_1 = require("./restapi");
+const duration_1 = require("../../duration");
+// import { Fn } from "../../terra-func";
+const aws_construct_1 = require("../aws-construct");
+class ResourceBase extends aws_construct_1.AwsConstructBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.children = {};
+    }
+    addResource(pathPart, options) {
+        return new Resource(this, pathPart, {
+            parent: this,
+            pathPart,
+            ...options,
+        });
+    }
+    addMethod(httpMethod, integration, options) {
+        return new method_1.Method(this, httpMethod, {
+            resource: this,
+            httpMethod,
+            integration,
+            options,
+        });
+    }
+    addProxy(options) {
+        return new ProxyResource(this, "{proxy+}", { parent: this, ...options });
+    }
+    addCorsPreflight(options) {
+        const headers = {};
+        const allowHeaders = options.allowHeaders || cors_1.Cors.DEFAULT_HEADERS;
+        headers["Access-Control-Allow-Headers"] = `'${allowHeaders.join(",")}'`;
+        if (options.allowOrigins.length === 0) {
+            throw new Error("allowOrigins must contain at least one origin");
+        }
+        if (options.allowOrigins.includes("*") && options.allowOrigins.length > 1) {
+            throw new Error(`Invalid "allowOrigins" - cannot mix "*" with specific origins: ${options.allowOrigins.join(",")}`);
+        }
+        const initialOrigin = options.allowOrigins[0];
+        headers["Access-Control-Allow-Origin"] = `'${initialOrigin}'`;
+        if (initialOrigin !== "*") {
+            headers.Vary = "'Origin'";
+        }
+        let allowMethods = options.allowMethods || cors_1.Cors.ALL_METHODS;
+        if (allowMethods.includes("ANY")) {
+            if (allowMethods.length > 1) {
+                throw new Error(`ANY cannot be used with any other method. Received: ${allowMethods.join(",")}`);
+            }
+            allowMethods = cors_1.Cors.ALL_METHODS;
+        }
+        headers["Access-Control-Allow-Methods"] = `'${allowMethods.join(",")}'`;
+        if (options.allowCredentials) {
+            headers["Access-Control-Allow-Credentials"] = "'true'";
+        }
+        let maxAgeSeconds;
+        if (options.maxAge && options.disableCache) {
+            throw new Error('The options "maxAge" and "disableCache" are mutually exclusive');
+        }
+        if (options.maxAge instanceof duration_1.Duration) {
+            maxAgeSeconds = options.maxAge.toSeconds();
+        }
+        if (options.disableCache) {
+            maxAgeSeconds = -1;
+        }
+        if (maxAgeSeconds !== undefined) {
+            headers["Access-Control-Max-Age"] = `'${maxAgeSeconds}'`;
+        }
+        if (options.exposeHeaders) {
+            headers["Access-Control-Expose-Headers"] = `'${options.exposeHeaders.join(",")}'`;
+        }
+        const statusCode = options.statusCode ?? 204;
+        const integrationResponseParams = {};
+        const methodResponseParams = {};
+        for (const [name, value] of Object.entries(headers)) {
+            const key = `method.response.header.${name}`;
+            integrationResponseParams[key] = value;
+            methodResponseParams[key] = true;
+        }
+        return this.addMethod("OPTIONS", new integrations_1.MockIntegration({
+            requestTemplates: { "application/json": "{ statusCode: 200 }" },
+            integrationResponses: [
+                {
+                    statusCode: `${statusCode}`,
+                    responseParameters: integrationResponseParams,
+                    responseTemplates: renderResponseTemplate(),
+                },
+            ],
+        }), {
+            // Assuming Authorizer has a static NONE or similar concept
+            authorizer: {
+                authorizerId: "", // Representing no authorizer
+                authorizationType: method_1.AuthorizationType.NONE,
+            },
+            apiKeyRequired: false,
+            authorizationType: method_1.AuthorizationType.NONE,
+            methodResponses: [
+                {
+                    statusCode: `${statusCode}`,
+                    responseParameters: methodResponseParams,
+                },
+            ],
+        });
+        function renderResponseTemplate() {
+            const origins = options.allowOrigins.slice(1);
+            if (origins.length === 0) {
+                return undefined;
+            }
+            const template = new Array();
+            template.push('#set($origin = $input.params().header.get("Origin"))', '#if($origin == "")', '  #set($origin = $input.params().header.get("origin"))', "#end");
+            const condition = origins.map((o) => `$origin == "${o}"`).join(" || ");
+            template.push(`#if(${condition})`);
+            template.push("  #set($context.responseOverride.header.Access-Control-Allow-Origin = $origin)");
+            template.push("#end");
+            return {
+                "application/json": template.join("\n"),
+            };
+        }
+    }
+    getResource(pathPart) {
+        return this.children[pathPart];
+    }
+    /**
+     * @internal
+     */
+    _trackChild(pathPart, resource) {
+        this.children[pathPart] = resource;
+    }
+    resourceForPath(path) {
+        if (!path) {
+            // This cast is safe because `this` conforms to `Resource` if path is empty.
+            return this;
+        }
+        if (path.startsWith("/")) {
+            if (this.path !== "/") {
+                throw new Error(`Path may start with "/" only for the root resource, but we are at: ${this.path}`);
+            }
+            return this.resourceForPath(path.slice(1));
+        }
+        const parts = path.split("/");
+        const next = parts.shift();
+        if (!next || next === "") {
+            throw new Error("resourceForPath cannot be called with an empty path");
+        }
+        let resource = this.getResource(next);
+        if (!resource) {
+            resource = this.addResource(next);
+        }
+        return resource.resourceForPath(parts.join("/"));
+    }
+    /**
+     * @deprecated - Throws error in some use cases that have been enabled since this deprecation notice. Use `RestApi.urlForPath()` instead.
+     */
+    get url() {
+        return this.restApi.urlForPath(this.path);
+    }
+    // Base AwsConstruct output, can be overridden by derived classes
+    get outputs() {
+        return {
+            resourceId: this.resourceId,
+            path: this.path,
+        };
+    }
+}
+exports.ResourceBase = ResourceBase;
+_a = JSII_RTTI_SYMBOL_1;
+ResourceBase[_a] = { fqn: "terraconstructs.aws.compute.ResourceBase", version: "0.1.0" };
+class Resource extends ResourceBase {
+    /**
+     * Import an existing resource
+     */
+    static fromResourceAttributes(scope, id, attrs) {
+        class Import extends ResourceBase {
+            constructor() {
+                super(...arguments);
+                this.api = attrs.restApi;
+                this.resourceId = attrs.resourceId;
+                this.path = attrs.path;
+                this.defaultIntegration = undefined;
+                this.defaultMethodOptions = undefined;
+                this.defaultCorsPreflightOptions = undefined;
+                this.parentResource = undefined; // Imported resources don't have a parent in the same construct tree
+            }
+            get restApi() {
+                if (this.api instanceof restapi_1.RestApi) {
+                    return this.api;
+                }
+                throw new Error("restApi is not available for this imported resource or it's not an instance of RestApi.");
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        validateResourcePathPart(props.pathPart, this);
+        this.parentResource = props.parent;
+        if (props.parent instanceof ResourceBase) {
+            props.parent._trackChild(props.pathPart, this);
+        }
+        const resourceProps = {
+            restApiId: props.parent.api.restApiId,
+            parentId: props.parent.resourceId,
+            pathPart: props.pathPart,
+        };
+        this._resource = new provider_aws_1.apiGatewayResource.ApiGatewayResource(this, "Resource", resourceProps);
+        this.resourceId = this._resource.id;
+        this.api = props.parent.api;
+        let currentPath = props.parent.path;
+        if (currentPath !== "/") {
+            // Ensure trailing slash for parent unless it's the root
+            if (!currentPath.endsWith("/")) {
+                currentPath += "/";
+            }
+            this.path = currentPath + props.pathPart;
+        }
+        else {
+            this.path = currentPath + props.pathPart;
+        }
+        const deployment = props.parent.api.latestDeployment;
+        if (deployment) {
+            deployment.node.addDependency(this._resource);
+            // CDKTF handles deployment updates based on resource changes implicitly or via explicit triggers.
+            // Fn.sha1(Fn.jsonencode()) causes nested Tokens and Resolver errors?
+            deployment.addToTriggers({ resource: resourceProps });
+            // The addToLogicalId part is CDK/CFN specific for logical ID stability.
+            // deployment.addToLogicalId({ resource: resourceProps });
+        }
+        this.defaultIntegration =
+            props.defaultIntegration || props.parent.defaultIntegration;
+        this.defaultMethodOptions = {
+            ...props.parent.defaultMethodOptions,
+            ...props.defaultMethodOptions,
+        };
+        this.defaultCorsPreflightOptions =
+            props.defaultCorsPreflightOptions ||
+                props.parent.defaultCorsPreflightOptions;
+        if (this.defaultCorsPreflightOptions) {
+            this.addCorsPreflight(this.defaultCorsPreflightOptions);
+        }
+    }
+    /**
+     * The RestApi associated with this Resource
+     * @deprecated - Throws an error if this Resource is not associated with an instance of `RestApi`. Use `api` instead.
+     */
+    get restApi() {
+        if (this.api instanceof restapi_1.RestApi) {
+            return this.api;
+        }
+        throw new Error("The 'api' property is not an instance of RestApi. The 'restApi' getter is deprecated and requires a concrete RestApi instance.");
+    }
+}
+exports.Resource = Resource;
+_b = JSII_RTTI_SYMBOL_1;
+Resource[_b] = { fqn: "terraconstructs.aws.compute.Resource", version: "0.1.0" };
+/**
+ * Defines a {proxy+} greedy resource and an ANY method on a route.
+ * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-set-up-simple-proxy.html
+ */
+class ProxyResource extends Resource {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            parent: props.parent,
+            pathPart: "{proxy+}",
+            defaultIntegration: props.defaultIntegration,
+            defaultMethodOptions: props.defaultMethodOptions,
+        });
+        const anyMethodEnabled = props.anyMethod ?? true;
+        if (anyMethodEnabled) {
+            this.anyMethod = this.addMethod("ANY");
+        }
+    }
+    addMethod(httpMethod, integration, options) {
+        if (this.parentResource && this.parentResource.path === "/") {
+            // Check if the method already exists on the parent to avoid duplication
+            const existingMethod = this.parentResource.node
+                .findAll()
+                .find((child) => child instanceof method_1.Method && child.httpMethod === httpMethod);
+            if (!existingMethod) {
+                this.parentResource.addMethod(httpMethod, integration, options);
+            }
+        }
+        return super.addMethod(httpMethod, integration, options);
+    }
+}
+exports.ProxyResource = ProxyResource;
+_c = JSII_RTTI_SYMBOL_1;
+ProxyResource[_c] = { fqn: "terraconstructs.aws.compute.ProxyResource", version: "0.1.0" };
+function validateResourcePathPart(part, scope) {
+    // strip {} which indicate this is a parameter
+    let validatedPart = part;
+    if (validatedPart.startsWith("{") && validatedPart.endsWith("}")) {
+        validatedPart = validatedPart.slice(1, -1);
+        // proxy resources are allowed to end with a '+'
+        // if (validatedPart.endsWith("+$")) {
+        if (validatedPart.endsWith("+")) {
+            validatedPart = validatedPart.slice(0, -1);
+        }
+    }
+    // REVERTED - CDK allows '$' but Terraform provider for aws_api_gateway_resource path_part
+    //            does not seem to explicitly list it.
+    // REVERTED - The regex /^[a-zA-Z0-9_.-]*$/ is often used for such identifiers.
+    // if (!/^[a-zA-Z0-9:._-]+$/.test(validatedPart)) {
+    if (!/^[a-zA-Z0-9:\.\_\-\$]+$/.test(validatedPart)) {
+        // Adjusted to match CDK's broader allowance, but this might need refinement based on actual provider constraints.
+        throw new Error(`Resource's path part can only contain alphanumeric characters, hyphens, underscores, periods, colons, an optional trailing '+'
+      and curly braces at the beginning and the end:. Path part: ${part} (${scope.node.path})`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource.js","sourceRoot":"","sources":["../../../src/aws/compute/resource.ts"],"names":[],"mappings":"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","sourcesContent":["import { apiGatewayResource } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { Cors, CorsOptions } from \"./cors\";\nimport { Integration } from \"./integration\";\nimport { MockIntegration } from \"./integrations\";\nimport { Method, MethodOptions, AuthorizationType } from \"./method\";\nimport { IRestApi, RestApi } from \"./restapi\";\nimport { Duration } from \"../../duration\";\n// import { Fn } from \"../../terra-func\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"../aws-construct\";\n\nexport interface IResource extends IAwsConstruct {\n  /**\n   * The parent of this resource or undefined for the root resource.\n   */\n  readonly parentResource?: IResource;\n\n  /**\n   * The rest API that this resource is part of.\n   *\n   * @deprecated - Throws an error if this Resource is not associated with an instance of `RestApi`. Use `api` instead.\n   */\n  readonly restApi: RestApi; // Assuming RestApi is a concrete class here as in CDK\n\n  /**\n   * The rest API that this resource is part of.\n   */\n  readonly api: IRestApi;\n\n  /**\n   * The ID of the resource.\n   * @attribute\n   */\n  readonly resourceId: string;\n\n  /**\n   * The full path of this resource.\n   */\n  readonly path: string;\n\n  /**\n   * An integration to use as a default for all methods created within this\n   * API unless an integration is specified.\n   */\n  readonly defaultIntegration?: Integration;\n\n  /**\n   * Method options to use as a default for all methods created within this\n   * API unless custom options are specified.\n   */\n  readonly defaultMethodOptions?: MethodOptions;\n\n  /**\n   * Default options for CORS preflight OPTIONS method.\n   */\n  readonly defaultCorsPreflightOptions?: CorsOptions;\n\n  /**\n   * Gets or create all resources leading up to the specified path.\n   *\n   * - Path may only start with \"/\" if this method is called on the root resource.\n   * - All resources are created using default options.\n   *\n   * @param path The relative path\n   * @returns a new or existing resource.\n   */\n  resourceForPath(path: string): Resource;\n\n  /**\n   * Defines a new child resource where this resource is the parent.\n   * @param pathPart The path part for the child resource\n   * @param options Resource options\n   * @returns A Resource object\n   */\n  addResource(pathPart: string, options?: ResourceOptions): Resource;\n\n  /**\n   * Retrieves a child resource by path part.\n   *\n   * @param pathPart The path part of the child resource\n   * @returns the child resource or undefined if not found\n   */\n  getResource(pathPart: string): IResource | undefined;\n\n  /**\n   * Adds a greedy proxy resource (\"{proxy+}\") and an ANY method to this route.\n   * @param options Default integration and method options.\n   */\n  addProxy(options?: ProxyResourceOptions): ProxyResource;\n\n  /**\n   * Defines a new method for this resource.\n   * @param httpMethod The HTTP method\n   * @param target The target backend integration for this method\n   * @param options Method options, such as authentication.\n   *\n   * @returns The newly created `Method` object.\n   */\n  addMethod(\n    httpMethod: string,\n    target?: Integration,\n    options?: MethodOptions,\n  ): Method;\n\n  /**\n   * Adds an OPTIONS method to this resource which responds to Cross-Origin\n   * Resource Sharing (CORS) preflight requests.\n   *\n   * @param options CORS options\n   * @returns a `Method` object\n   */\n  addCorsPreflight(options: CorsOptions): Method;\n}\n\nexport interface ResourceOptions {\n  /**\n   * An integration to use as a default for all methods created within this\n   * API unless an integration is specified.\n   *\n   * @default - Inherited from parent.\n   */\n  readonly defaultIntegration?: Integration;\n\n  /**\n   * Method options to use as a default for all methods created within this\n   * API unless custom options are specified.\n   *\n   * @default - Inherited from parent.\n   */\n  readonly defaultMethodOptions?: MethodOptions;\n\n  /**\n   * Adds a CORS preflight OPTIONS method to this resource and all child\n   * resources.\n   *\n   * You can add CORS at the resource-level using `addCorsPreflight`.\n   *\n   * @default - CORS is disabled\n   */\n  readonly defaultCorsPreflightOptions?: CorsOptions;\n}\n\nexport interface ResourceProps extends ResourceOptions, AwsConstructProps {\n  /**\n   * The parent resource of this resource. You can either pass another\n   * `Resource` object or a `RestApi` object here.\n   */\n  readonly parent: IResource;\n\n  /**\n   * A path name for the resource.\n   */\n  readonly pathPart: string;\n}\n\nexport abstract class ResourceBase\n  extends AwsConstructBase\n  implements IResource\n{\n  public abstract readonly parentResource?: IResource;\n  /**\n   * @deprecated -  Throws an error if this Resource is not associated with an instance of `RestApi`. Use `api` instead.\n   */\n  public abstract get restApi(): RestApi;\n  public abstract readonly api: IRestApi;\n  public abstract readonly resourceId: string;\n  public abstract readonly path: string;\n  public abstract readonly defaultIntegration?: Integration;\n  public abstract readonly defaultMethodOptions?: MethodOptions;\n  public abstract readonly defaultCorsPreflightOptions?: CorsOptions;\n\n  private readonly children: { [pathPart: string]: Resource } = {};\n\n  constructor(scope: Construct, id: string, props?: AwsConstructProps) {\n    super(scope, id, props);\n  }\n\n  public addResource(pathPart: string, options?: ResourceOptions): Resource {\n    return new Resource(this, pathPart, {\n      parent: this,\n      pathPart,\n      ...options,\n    });\n  }\n\n  public addMethod(\n    httpMethod: string,\n    integration?: Integration,\n    options?: MethodOptions,\n  ): Method {\n    return new Method(this, httpMethod, {\n      resource: this,\n      httpMethod,\n      integration,\n      options,\n    });\n  }\n\n  public addProxy(options?: ProxyResourceOptions): ProxyResource {\n    return new ProxyResource(this, \"{proxy+}\", { parent: this, ...options });\n  }\n\n  public addCorsPreflight(options: CorsOptions): Method {\n    const headers: { [name: string]: string } = {};\n\n    const allowHeaders = options.allowHeaders || Cors.DEFAULT_HEADERS;\n    headers[\"Access-Control-Allow-Headers\"] = `'${allowHeaders.join(\",\")}'`;\n\n    if (options.allowOrigins.length === 0) {\n      throw new Error(\"allowOrigins must contain at least one origin\");\n    }\n\n    if (options.allowOrigins.includes(\"*\") && options.allowOrigins.length > 1) {\n      throw new Error(\n        `Invalid \"allowOrigins\" - cannot mix \"*\" with specific origins: ${options.allowOrigins.join(\n          \",\",\n        )}`,\n      );\n    }\n\n    const initialOrigin = options.allowOrigins[0];\n    headers[\"Access-Control-Allow-Origin\"] = `'${initialOrigin}'`;\n\n    if (initialOrigin !== \"*\") {\n      headers.Vary = \"'Origin'\";\n    }\n\n    let allowMethods = options.allowMethods || Cors.ALL_METHODS;\n\n    if (allowMethods.includes(\"ANY\")) {\n      if (allowMethods.length > 1) {\n        throw new Error(\n          `ANY cannot be used with any other method. Received: ${allowMethods.join(\n            \",\",\n          )}`,\n        );\n      }\n      allowMethods = Cors.ALL_METHODS;\n    }\n\n    headers[\"Access-Control-Allow-Methods\"] = `'${allowMethods.join(\",\")}'`;\n\n    if (options.allowCredentials) {\n      headers[\"Access-Control-Allow-Credentials\"] = \"'true'\";\n    }\n\n    let maxAgeSeconds: number | undefined;\n\n    if (options.maxAge && options.disableCache) {\n      throw new Error(\n        'The options \"maxAge\" and \"disableCache\" are mutually exclusive',\n      );\n    }\n\n    if (options.maxAge instanceof Duration) {\n      maxAgeSeconds = options.maxAge.toSeconds();\n    }\n\n    if (options.disableCache) {\n      maxAgeSeconds = -1;\n    }\n\n    if (maxAgeSeconds !== undefined) {\n      headers[\"Access-Control-Max-Age\"] = `'${maxAgeSeconds}'`;\n    }\n\n    if (options.exposeHeaders) {\n      headers[\"Access-Control-Expose-Headers\"] = `'${options.exposeHeaders.join(\n        \",\",\n      )}'`;\n    }\n\n    const statusCode = options.statusCode ?? 204;\n\n    const integrationResponseParams: { [p: string]: string } = {};\n    const methodResponseParams: { [p: string]: boolean } = {};\n\n    for (const [name, value] of Object.entries(headers)) {\n      const key = `method.response.header.${name}`;\n      integrationResponseParams[key] = value;\n      methodResponseParams[key] = true;\n    }\n\n    return this.addMethod(\n      \"OPTIONS\",\n      new MockIntegration({\n        requestTemplates: { \"application/json\": \"{ statusCode: 200 }\" },\n        integrationResponses: [\n          {\n            statusCode: `${statusCode}`,\n            responseParameters: integrationResponseParams,\n            responseTemplates: renderResponseTemplate(),\n          },\n        ],\n      }),\n      {\n        // Assuming Authorizer has a static NONE or similar concept\n        authorizer: {\n          authorizerId: \"\", // Representing no authorizer\n          authorizationType: AuthorizationType.NONE,\n        },\n        apiKeyRequired: false,\n        authorizationType: AuthorizationType.NONE,\n        methodResponses: [\n          {\n            statusCode: `${statusCode}`,\n            responseParameters: methodResponseParams,\n          },\n        ],\n      },\n    );\n\n    function renderResponseTemplate() {\n      const origins = options.allowOrigins.slice(1);\n\n      if (origins.length === 0) {\n        return undefined;\n      }\n\n      const template = new Array<string>();\n\n      template.push(\n        '#set($origin = $input.params().header.get(\"Origin\"))',\n        '#if($origin == \"\")',\n        '  #set($origin = $input.params().header.get(\"origin\"))',\n        \"#end\",\n      );\n\n      const condition = origins.map((o) => `$origin == \"${o}\"`).join(\" || \");\n\n      template.push(`#if(${condition})`);\n      template.push(\n        \"  #set($context.responseOverride.header.Access-Control-Allow-Origin = $origin)\",\n      );\n      template.push(\"#end\");\n\n      return {\n        \"application/json\": template.join(\"\\n\"),\n      };\n    }\n  }\n\n  public getResource(pathPart: string): IResource | undefined {\n    return this.children[pathPart];\n  }\n\n  /**\n   * @internal\n   */\n  public _trackChild(pathPart: string, resource: Resource) {\n    this.children[pathPart] = resource;\n  }\n\n  public resourceForPath(path: string): Resource {\n    if (!path) {\n      // This cast is safe because `this` conforms to `Resource` if path is empty.\n      return this as unknown as Resource;\n    }\n\n    if (path.startsWith(\"/\")) {\n      if (this.path !== \"/\") {\n        throw new Error(\n          `Path may start with \"/\" only for the root resource, but we are at: ${this.path}`,\n        );\n      }\n      return this.resourceForPath(path.slice(1));\n    }\n\n    const parts = path.split(\"/\");\n    const next = parts.shift();\n    if (!next || next === \"\") {\n      throw new Error(\"resourceForPath cannot be called with an empty path\");\n    }\n\n    let resource = this.getResource(next) as Resource | undefined;\n    if (!resource) {\n      resource = this.addResource(next);\n    }\n\n    return resource.resourceForPath(parts.join(\"/\"));\n  }\n\n  /**\n   * @deprecated - Throws error in some use cases that have been enabled since this deprecation notice. Use `RestApi.urlForPath()` instead.\n   */\n  public get url(): string {\n    return this.restApi.urlForPath(this.path);\n  }\n\n  // Base AwsConstruct output, can be overridden by derived classes\n  public get outputs(): Record<string, any> {\n    return {\n      resourceId: this.resourceId,\n      path: this.path,\n    };\n  }\n}\n\n/**\n * Attributes that can be specified when importing a Resource\n */\nexport interface ResourceAttributes {\n  /**\n   * The ID of the resource.\n   */\n  readonly resourceId: string;\n\n  /**\n   * The rest API that this resource is part of.\n   */\n  readonly restApi: IRestApi;\n\n  /**\n   * The full path of this resource.\n   */\n  readonly path: string;\n}\n\nexport class Resource extends ResourceBase {\n  /**\n   * Import an existing resource\n   */\n  public static fromResourceAttributes(\n    scope: Construct,\n    id: string,\n    attrs: ResourceAttributes,\n  ): IResource {\n    class Import extends ResourceBase {\n      public readonly api = attrs.restApi;\n      public readonly resourceId = attrs.resourceId;\n      public readonly path = attrs.path;\n      public readonly defaultIntegration?: Integration = undefined;\n      public readonly defaultMethodOptions?: MethodOptions = undefined;\n      public readonly defaultCorsPreflightOptions?: CorsOptions = undefined;\n      public readonly parentResource?: IResource = undefined; // Imported resources don't have a parent in the same construct tree\n\n      public get restApi(): RestApi {\n        if (this.api instanceof RestApi) {\n          return this.api;\n        }\n        throw new Error(\n          \"restApi is not available for this imported resource or it's not an instance of RestApi.\",\n        );\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  public readonly parentResource?: IResource;\n  public readonly api: IRestApi;\n  public readonly resourceId: string;\n  public readonly path: string;\n\n  public readonly defaultIntegration?: Integration;\n  public readonly defaultMethodOptions?: MethodOptions;\n  public readonly defaultCorsPreflightOptions?: CorsOptions;\n\n  private readonly _resource: apiGatewayResource.ApiGatewayResource;\n\n  constructor(scope: Construct, id: string, props: ResourceProps) {\n    super(scope, id, props);\n\n    validateResourcePathPart(props.pathPart, this);\n\n    this.parentResource = props.parent;\n\n    if (props.parent instanceof ResourceBase) {\n      props.parent._trackChild(props.pathPart, this);\n    }\n\n    const resourceProps: apiGatewayResource.ApiGatewayResourceConfig = {\n      restApiId: props.parent.api.restApiId,\n      parentId: props.parent.resourceId,\n      pathPart: props.pathPart,\n    };\n    this._resource = new apiGatewayResource.ApiGatewayResource(\n      this,\n      \"Resource\",\n      resourceProps,\n    );\n\n    this.resourceId = this._resource.id;\n    this.api = props.parent.api;\n\n    let currentPath = props.parent.path;\n    if (currentPath !== \"/\") {\n      // Ensure trailing slash for parent unless it's the root\n      if (!currentPath.endsWith(\"/\")) {\n        currentPath += \"/\";\n      }\n      this.path = currentPath + props.pathPart;\n    } else {\n      this.path = currentPath + props.pathPart;\n    }\n\n    const deployment = props.parent.api.latestDeployment;\n    if (deployment) {\n      deployment.node.addDependency(this._resource);\n      // CDKTF handles deployment updates based on resource changes implicitly or via explicit triggers.\n      // Fn.sha1(Fn.jsonencode()) causes nested Tokens and Resolver errors?\n      deployment.addToTriggers({ resource: resourceProps });\n      // The addToLogicalId part is CDK/CFN specific for logical ID stability.\n      // deployment.addToLogicalId({ resource: resourceProps });\n    }\n\n    this.defaultIntegration =\n      props.defaultIntegration || props.parent.defaultIntegration;\n    this.defaultMethodOptions = {\n      ...props.parent.defaultMethodOptions,\n      ...props.defaultMethodOptions,\n    };\n    this.defaultCorsPreflightOptions =\n      props.defaultCorsPreflightOptions ||\n      props.parent.defaultCorsPreflightOptions;\n\n    if (this.defaultCorsPreflightOptions) {\n      this.addCorsPreflight(this.defaultCorsPreflightOptions);\n    }\n  }\n\n  /**\n   * The RestApi associated with this Resource\n   * @deprecated - Throws an error if this Resource is not associated with an instance of `RestApi`. Use `api` instead.\n   */\n  public get restApi(): RestApi {\n    if (this.api instanceof RestApi) {\n      return this.api;\n    }\n    throw new Error(\n      \"The 'api' property is not an instance of RestApi. The 'restApi' getter is deprecated and requires a concrete RestApi instance.\",\n    );\n  }\n}\n\nexport interface ProxyResourceOptions extends ResourceOptions {\n  /**\n   * Adds an \"ANY\" method to this resource. If set to `false`, you will have to explicitly\n   * add methods to this resource after it's created.\n   *\n   * @default true\n   */\n  readonly anyMethod?: boolean;\n}\n\nexport interface ProxyResourceProps extends ProxyResourceOptions {\n  /**\n   * The parent resource of this resource. You can either pass another\n   * `Resource` object or a `RestApi` object here.\n   */\n  readonly parent: IResource;\n}\n\n/**\n * Defines a {proxy+} greedy resource and an ANY method on a route.\n * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-set-up-simple-proxy.html\n */\nexport class ProxyResource extends Resource {\n  /**\n   * If `props.anyMethod` is `true`, this will be the reference to the 'ANY'\n   * method associated with this proxy resource.\n   */\n  public readonly anyMethod?: Method;\n\n  constructor(scope: Construct, id: string, props: ProxyResourceProps) {\n    super(scope, id, {\n      parent: props.parent,\n      pathPart: \"{proxy+}\",\n      defaultIntegration: props.defaultIntegration,\n      defaultMethodOptions: props.defaultMethodOptions,\n    });\n\n    const anyMethodEnabled = props.anyMethod ?? true;\n    if (anyMethodEnabled) {\n      this.anyMethod = this.addMethod(\"ANY\");\n    }\n  }\n\n  public addMethod(\n    httpMethod: string,\n    integration?: Integration,\n    options?: MethodOptions,\n  ): Method {\n    if (this.parentResource && this.parentResource.path === \"/\") {\n      // Check if the method already exists on the parent to avoid duplication\n      const existingMethod = this.parentResource.node\n        .findAll()\n        .find(\n          (child) => child instanceof Method && child.httpMethod === httpMethod,\n        );\n      if (!existingMethod) {\n        this.parentResource.addMethod(httpMethod, integration, options);\n      }\n    }\n    return super.addMethod(httpMethod, integration, options);\n  }\n}\n\nfunction validateResourcePathPart(part: string, scope: Construct) {\n  // strip {} which indicate this is a parameter\n  let validatedPart = part;\n  if (validatedPart.startsWith(\"{\") && validatedPart.endsWith(\"}\")) {\n    validatedPart = validatedPart.slice(1, -1);\n\n    // proxy resources are allowed to end with a '+'\n    // if (validatedPart.endsWith(\"+$\")) {\n    if (validatedPart.endsWith(\"+\")) {\n      validatedPart = validatedPart.slice(0, -1);\n    }\n  }\n\n  // REVERTED - CDK allows '$' but Terraform provider for aws_api_gateway_resource path_part\n  //            does not seem to explicitly list it.\n  // REVERTED - The regex /^[a-zA-Z0-9_.-]*$/ is often used for such identifiers.\n  // if (!/^[a-zA-Z0-9:._-]+$/.test(validatedPart)) {\n  if (!/^[a-zA-Z0-9:\\.\\_\\-\\$]+$/.test(validatedPart)) {\n    // Adjusted to match CDK's broader allowance, but this might need refinement based on actual provider constraints.\n    throw new Error(\n      `Resource's path part can only contain alphanumeric characters, hyphens, underscores, periods, colons, an optional trailing '+'\n      and curly braces at the beginning and the end:. Path part: ${part} (${scope.node.path})`,\n    );\n  }\n}\n"]}