@aws/pdk
Version:
All documentation is located at: https://aws.github.io/aws-pdk
377 lines • 63.1 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.prepareApiSpec = exports.generateGatewayResponse = exports.validatePathItem = exports.generateCorsResponseParameters = exports.concatMethodAndPath = void 0;
const constants_1 = require("./constants");
/**
* Serialise a method and path into a single string
*/
const concatMethodAndPath = ({ method, path }) => `${method.toLowerCase()}||${path.toLowerCase()}`;
exports.concatMethodAndPath = concatMethodAndPath;
/**
* Return an array of security scheme references including the api key one if required
*/
const apiKeySecurityReference = (options) => options?.apiKeyRequired ? [{ [constants_1.DefaultAuthorizerIds.API_KEY]: [] }] : [];
/**
* Generate a "no auth" spec snippet
*/
const noAuthSpecSnippet = (options) => ({
security: apiKeySecurityReference(options),
"x-amazon-apigateway-auth": {
type: "NONE",
},
});
/**
* Create the OpenAPI definition with api gateway extensions for the given authorizer
* @param methodAuthorizer the authorizer used for the method
* @param options api integration options
*/
const applyMethodAuthorizer = (methodAuthorizer, options) => {
if (methodAuthorizer || options) {
if (methodAuthorizer?.authorizerId === constants_1.DefaultAuthorizerIds.NONE) {
return noAuthSpecSnippet(options);
}
else {
return {
security: [
...(methodAuthorizer
? [
{
[methodAuthorizer.authorizerId]: methodAuthorizer.authorizationScopes || [],
},
]
: []),
...apiKeySecurityReference(options),
],
};
}
}
return {};
};
/**
* Adds API Gateway integrations and auth to the given operation
*/
const applyMethodIntegration = (path, method, { integrations, corsOptions, apiKeyOptions, defaultAuthorizerReference, }, operation, getOperationName) => {
const operationName = getOperationName({ method, path });
if (!(operationName in integrations)) {
throw new Error(`Missing required integration for operation ${operationName} (${method} ${path})`);
}
let { methodAuthorizer, integration, options } = integrations[operationName];
validateAuthorizerReference(methodAuthorizer, operation.security, operationName);
let methodApiKeyOptions = options;
// When no API key options are present on the method, require the API key if it's
// required by default
if (!methodApiKeyOptions && apiKeyOptions?.requiredByDefault) {
methodApiKeyOptions = { apiKeyRequired: true };
}
// Can only "require" an API key if it's in a header, since we only define the security
// scheme we'd reference in this case.
if (apiKeyOptions?.source !== "HEADER" &&
methodApiKeyOptions?.apiKeyRequired) {
throw new Error(`Cannot require an API Key when API Key source is not HEADER: ${operationName} (${method} ${path})`);
}
// Apply the default authorizer unless a method authorizer is defined
methodAuthorizer = methodAuthorizer ?? defaultAuthorizerReference;
return {
...operation,
responses: Object.fromEntries(Object.entries(operation.responses).map(([statusCode, response]) => [
statusCode,
{
...response,
headers: {
...(corsOptions ? getCorsHeaderDefinitions() : {}),
// TODO: Consider following response header references
...response.headers,
},
},
])),
// https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-swagger-extensions-integration.html
"x-amazon-apigateway-integration": integration,
...applyMethodAuthorizer(methodAuthorizer, methodApiKeyOptions),
};
};
const getCorsHeaderDefinitions = () => ({
"Access-Control-Allow-Origin": {
schema: { type: "string" },
},
"Access-Control-Allow-Methods": {
schema: { type: "string" },
},
"Access-Control-Allow-Headers": {
schema: { type: "string" },
},
});
const generateCorsResponseHeaders = (corsOptions) => ({
"Access-Control-Allow-Headers": `'${corsOptions.allowHeaders.join(",")}'`,
"Access-Control-Allow-Methods": `'${corsOptions.allowMethods.join(",")}'`,
"Access-Control-Allow-Origin": `'${corsOptions.allowOrigins.join(",")}'`,
});
const generateCorsResponseParameters = (corsOptions, prefix = "method.response.header") => Object.fromEntries(Object.entries(generateCorsResponseHeaders(corsOptions)).map(([header, value]) => [`${prefix}.${header}`, value]));
exports.generateCorsResponseParameters = generateCorsResponseParameters;
/**
* Generates an "options" method with no auth to respond with the appropriate headers if cors is enabled
*/
const generateCorsOptionsMethod = (pathItem, { corsOptions }) => {
// Do not generate if already manually defined, or cors not enabled
if (constants_1.HttpMethods.OPTIONS in pathItem || !corsOptions) {
return {};
}
const statusCode = corsOptions.statusCode;
return {
[constants_1.HttpMethods.OPTIONS]: {
summary: "CORS Support",
description: "Enable CORS by returning the correct headers",
responses: {
[`${statusCode}`]: {
description: "Default response for CORS method",
headers: getCorsHeaderDefinitions(),
content: {},
},
},
// @ts-ignore Ignore apigateway extensions which are not part of default openapi spec type
"x-amazon-apigateway-integration": {
type: "mock",
requestTemplates: {
"application/json": `{"statusCode": ${statusCode}}`,
},
responses: {
default: {
statusCode: `${statusCode}`,
responseParameters: (0, exports.generateCorsResponseParameters)(corsOptions),
responseTemplates: {
"application/json": "{}",
},
},
},
},
// No auth for CORS options requests
...noAuthSpecSnippet(),
},
};
};
const validatePathItem = (path, pathItem) => {
const supportedPathItemKeys = new Set([
// https://spec.openapis.org/oas/v3.0.3#path-item-object
...Object.values(constants_1.HttpMethods),
"summary",
"description",
"parameters",
"servers",
// All $refs should be resolved already, so we'll error if one remains somehow
]);
const unsupportedMethodsInSpec = Object.keys(pathItem).filter((method) => !supportedPathItemKeys.has(method));
if (unsupportedMethodsInSpec.length > 0) {
throw new Error(`Path ${path} contains unsupported method${unsupportedMethodsInSpec.length > 1 ? "s" : ""} ${unsupportedMethodsInSpec.join(", ")}. Supported methods are ${Object.values(constants_1.HttpMethods).join(", ")}.`);
}
};
exports.validatePathItem = validatePathItem;
/**
* Prepares a given api path by adding integrations, configuring auth
*/
const preparePathSpec = (path, pathItem, options, getOperationName) => {
(0, exports.validatePathItem)(path, pathItem);
return {
...pathItem,
...Object.fromEntries(Object.values(constants_1.HttpMethods)
.filter((method) => pathItem[method])
.map((method) => [
method,
applyMethodIntegration(path, method, options, pathItem[method], getOperationName),
])),
// Generate an 'options' method required for CORS preflight requests if cors is enabled
...generateCorsOptionsMethod(pathItem, options),
};
};
/**
* Return whether the given OpenAPI object is a reference object
*/
const isRef = (obj) => "$ref" in obj;
/**
* Validate the construct security schemes against the security schemes in the original spec.
* Construct-defined authorizers always override those in the spec if they have the same ID, however we validate that
* we are not overriding an authorizer of a different type to avoid mistakes/mismatches between the spec and the
* construct.
* @param constructSecuritySchemes security schemes generated from the construct authorizers
* @param existingSpecSecuritySchemes security schemes already defined in the spec
*/
const validateSecuritySchemes = (constructSecuritySchemes, existingSpecSecuritySchemes) => {
if (existingSpecSecuritySchemes) {
const constructSecuritySchemeIds = new Set(Object.keys(constructSecuritySchemes));
const existingSecuritySchemeIds = new Set(Object.keys(existingSpecSecuritySchemes));
const overlappingSecuritySchemeIds = [...constructSecuritySchemeIds].filter((id) => existingSecuritySchemeIds.has(id));
// Any overlapping security schemes (defined in both the spec (or source smithy model) and the construct) must be of the same type.
// The one defined in the construct will take precedence since a custom/cognito authorizer can have a resolved arn in the construct,
// and we allow usage in the model as a forward definition with blank arn.
overlappingSecuritySchemeIds.forEach((schemeId) => {
if (!isRef(existingSpecSecuritySchemes[schemeId])) {
const existingScheme = existingSpecSecuritySchemes[schemeId];
if (constructSecuritySchemes[schemeId].type !== existingScheme.type) {
throw new Error(`Security scheme with id ${schemeId} was of type ${constructSecuritySchemes[schemeId].type} in construct but ${existingScheme.type} in OpenAPI spec or Smithy model.`);
}
const constructApiGatewayAuthType = constructSecuritySchemes[schemeId]["x-amazon-apigateway-authtype"];
const existingApiGatewayAuthType = existingScheme["x-amazon-apigateway-authtype"];
if (constructApiGatewayAuthType !== existingApiGatewayAuthType) {
throw new Error(`Security scheme with id ${schemeId} was of type ${constructApiGatewayAuthType} in construct but ${existingApiGatewayAuthType} in OpenAPI spec or Smithy model.`);
}
}
else {
throw new Error(`Security scheme with id ${schemeId} is a reference in the OpenAPI spec or Smithy model which is not supported.`);
}
});
}
};
/**
* Validate the given authorizer reference (either default or at an operation level) defined in the construct against
* those already in the spec.
* @param constructAuthorizer the authorizer defined in the construct
* @param existingSpecAuthorizers the authorizers already defined in the spec
* @param operation the operation we are validating (for clearer error messages)
*/
const validateAuthorizerReference = (constructAuthorizer, existingSpecAuthorizers, operation = "Default") => {
// Only need to validate if defined in both - if just one we'll use that.
if (constructAuthorizer && existingSpecAuthorizers) {
const mergedSpecAuthorizers = Object.fromEntries(existingSpecAuthorizers.flatMap((securityRequirement) => Object.keys(securityRequirement).map((id) => [
id,
securityRequirement[id],
])));
const specAuthorizerIds = Object.keys(mergedSpecAuthorizers);
if (specAuthorizerIds.length > 1) {
// Spec defined multiple authorizers but the construct can only specify one
throw new Error(`${operation} authorizers ${specAuthorizerIds
.sort()
.join(", ")} defined in the OpenAPI Spec or Smithy Model would be overridden by single construct authorizer ${constructAuthorizer.authorizerId}`);
}
else if (specAuthorizerIds.length === 1) {
// Single authorizer - check that they have the same id
if (specAuthorizerIds[0] !== constructAuthorizer.authorizerId) {
throw new Error(`${operation} authorizer ${specAuthorizerIds[0]} defined in the OpenAPI Spec or Smithy Model would be overridden by construct authorizer ${constructAuthorizer.authorizerId}`);
}
// Check that there are no differing scopes between the construct and spec
const specScopes = new Set(mergedSpecAuthorizers[specAuthorizerIds[0]]);
const constructScopes = new Set(constructAuthorizer.authorizationScopes);
const differingScopes = [
...[...specScopes].filter((scope) => !constructScopes.has(scope)),
...[...constructScopes].filter((scope) => !specScopes.has(scope)),
];
if (differingScopes.length > 0) {
throw new Error(`${operation} authorizer scopes ${[...specScopes].join(", ")} defined in the OpenAPI Spec or Smithy Model differ from those in the construct (${[
...constructScopes,
].join(", ")})`);
}
}
else if (constructAuthorizer.authorizerId !== constants_1.DefaultAuthorizerIds.NONE) {
// "security" section of spec is [] which means no auth, but the authorizer in the construct is not the "none" authorizer.
throw new Error(`${operation} explicitly defines no auth in the OpenAPI Spec or Smithy Model which would be overridden by construct authorizer ${constructAuthorizer.authorizerId}`);
}
}
};
/**
* Find all unique header parameters used in operations
*/
const findHeaderParameters = (spec) => {
const allHeaderParameters = Object.values(spec.paths).flatMap((pathDetails) => Object.values(constants_1.HttpMethods).flatMap((method) => (pathDetails?.[method]?.parameters ?? []).flatMap((parameter) => "in" in parameter && parameter.in === "header" ? [parameter.name] : [])));
const headerParameterSet = new Set();
return allHeaderParameters.filter((p) => {
const seen = headerParameterSet.has(p);
headerParameterSet.add(p);
return !seen;
});
};
/**
* Generate a gateway response snippet
* @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-swagger-extensions-gateway-responses.gatewayResponse.html
*/
const generateGatewayResponse = ({ statusCode, templates, responseHeaders, }) => {
return {
statusCode,
...(responseHeaders
? {
responseParameters: Object.fromEntries(Object.entries(responseHeaders).map(([header, value]) => [
`gatewayresponse.header.${header}`,
value,
])),
}
: {}),
responseTemplates: templates,
};
};
exports.generateGatewayResponse = generateGatewayResponse;
/**
* Prepares the api spec for deployment by adding integrations, configuring auth, etc
*/
const prepareApiSpec = (spec, options) => {
// Reverse lookup for the operation name given a method and path
const operationNameByPath = Object.fromEntries(Object.entries(options.operationLookup).map(([operationName, methodAndPath]) => [
(0, exports.concatMethodAndPath)(methodAndPath),
operationName,
]));
const getOperationName = (methodAndPath) => operationNameByPath[(0, exports.concatMethodAndPath)(methodAndPath)];
validateSecuritySchemes(options.securitySchemes, spec.components?.securitySchemes);
validateAuthorizerReference(options.defaultAuthorizerReference, spec.security);
// If there are cors options, add any header parameters defined in the spec as allowed headers to
// save users from having to manually specify these (or face cors issues!)
const corsOptions = options.corsOptions
? {
...options.corsOptions,
allowHeaders: [
...options.corsOptions.allowHeaders,
...findHeaderParameters(spec),
],
}
: undefined;
const updatedOptions = {
...options,
corsOptions,
};
return {
...spec,
// https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-swagger-extensions-request-validators.html
"x-amazon-apigateway-request-validators": {
all: {
validateRequestBody: true,
validateRequestParameters: true,
},
},
"x-amazon-apigateway-request-validator": "all",
// https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-swagger-extensions-gateway-responses.html
"x-amazon-apigateway-gateway-responses": {
BAD_REQUEST_BODY: {
statusCode: 400,
responseTemplates: {
"application/json": '{"message": "$context.error.validationErrorString"}',
},
...(corsOptions
? {
responseParameters: (0, exports.generateCorsResponseParameters)(corsOptions, "gatewayresponse.header"),
}
: {}),
},
...Object.fromEntries((options.gatewayResponses ?? []).map((gatewayResponse) => [
gatewayResponse.type.responseType,
(0, exports.generateGatewayResponse)(gatewayResponse),
])),
},
paths: {
...Object.fromEntries(Object.entries(spec.paths).map(([path, pathDetails]) => [
path,
preparePathSpec(path, pathDetails, updatedOptions, getOperationName),
])),
},
components: {
...spec.components,
securitySchemes: {
// Apply any security schemes that already exist in the spec
...spec.components?.securitySchemes,
// Construct security schemes override any in the spec with the same id
...updatedOptions.securitySchemes,
},
},
...(updatedOptions.apiKeyOptions
? {
// https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-swagger-extensions-api-key-source.html
"x-amazon-apigateway-api-key-source": updatedOptions.apiKeyOptions.source,
}
: {}),
};
};
exports.prepareApiSpec = prepareApiSpec;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prepare-spec.js","sourceRoot":"","sources":["prepare-spec.ts"],"names":[],"mappings":"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","sourcesContent":["/*! Copyright [Amazon.com](http://amazon.com/), Inc. or its affiliates. All Rights Reserved.\nSPDX-License-Identifier: Apache-2.0 */\nimport { GatewayResponseOptions } from \"aws-cdk-lib/aws-apigateway\";\nimport type { OpenAPIV3 } from \"openapi-types\";\nimport { DefaultAuthorizerIds, HttpMethods } from \"./constants\";\nimport { ApiGatewayIntegration } from \"../integrations\";\nimport type {\n  Method,\n  MethodAndPath,\n  OperationLookup,\n  SerializedCorsOptions,\n  TypeSafeApiIntegrationOptions,\n  TypeSafeApiIntegrations,\n} from \"../spec\";\nimport { SerialisedAuthorizerReference } from \"../spec/api-gateway-auth\";\n\n/**\n * Serialise a method and path into a single string\n */\nexport const concatMethodAndPath = ({ method, path }: MethodAndPath) =>\n  `${method.toLowerCase()}||${path.toLowerCase()}`;\n\n/**\n * Serialized integration for a method\n */\nexport interface SerializedMethodIntegration {\n  /**\n   * The lambda function invocation uri for the api method\n   */\n  readonly integration: ApiGatewayIntegration;\n  /**\n   * The authorizer (if any) to apply to the method\n   */\n  readonly methodAuthorizer?: SerialisedAuthorizerReference;\n  /**\n   * Options for the integration\n   */\n  readonly options?: TypeSafeApiIntegrationOptions;\n}\n\n/**\n * Options for API keys\n */\nexport interface SerializedApiKeyOptions {\n  /**\n   * Source type for an API key\n   */\n  readonly source: string;\n  /**\n   * Set to true to require an API key on all operations by default.\n   * Only applicable when the source is HEADER.\n   */\n  readonly requiredByDefault?: boolean;\n}\n\n/**\n * Options for preparing an api spec for deployment by api gateway\n */\nexport interface PrepareApiSpecOptions {\n  /**\n   * Integrations for api operations\n   */\n  readonly integrations: { [operationId: string]: SerializedMethodIntegration };\n  /**\n   * Options for cross-origin resource sharing\n   */\n  readonly corsOptions?: SerializedCorsOptions;\n  /**\n   * Operation id to method and path mapping\n   */\n  readonly operationLookup: OperationLookup;\n  /**\n   * Security schemes to add to the spec\n   */\n  readonly securitySchemes: { [key: string]: OpenAPIV3.SecuritySchemeObject };\n  /**\n   * The default authorizer to reference\n   */\n  readonly defaultAuthorizerReference?: SerialisedAuthorizerReference;\n  /**\n   * Default options for API keys\n   */\n  readonly apiKeyOptions?: SerializedApiKeyOptions;\n  /**\n   * Optional gateway responses for the API\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html\n   */\n  readonly gatewayResponses?: GatewayResponseOptions[];\n}\n\n/**\n * API key options when rendering an authorizer\n */\ninterface AuthorizerApiKeyOptions {\n  /**\n   * Whether an api key is required for the method\n   */\n  readonly apiKeyRequired?: boolean;\n}\n\n/**\n * Return an array of security scheme references including the api key one if required\n */\nconst apiKeySecurityReference = (options?: AuthorizerApiKeyOptions) =>\n  options?.apiKeyRequired ? [{ [DefaultAuthorizerIds.API_KEY]: [] }] : [];\n\n/**\n * Generate a \"no auth\" spec snippet\n */\nconst noAuthSpecSnippet = (options?: AuthorizerApiKeyOptions) => ({\n  security: apiKeySecurityReference(options),\n  \"x-amazon-apigateway-auth\": {\n    type: \"NONE\",\n  },\n});\n\n/**\n * Create the OpenAPI definition with api gateway extensions for the given authorizer\n * @param methodAuthorizer the authorizer used for the method\n * @param options api integration options\n */\nconst applyMethodAuthorizer = (\n  methodAuthorizer?: SerialisedAuthorizerReference,\n  options?: AuthorizerApiKeyOptions\n) => {\n  if (methodAuthorizer || options) {\n    if (methodAuthorizer?.authorizerId === DefaultAuthorizerIds.NONE) {\n      return noAuthSpecSnippet(options);\n    } else {\n      return {\n        security: [\n          ...(methodAuthorizer\n            ? [\n                {\n                  [methodAuthorizer.authorizerId]:\n                    methodAuthorizer.authorizationScopes || [],\n                },\n              ]\n            : []),\n          ...apiKeySecurityReference(options),\n        ],\n      };\n    }\n  }\n  return {};\n};\n\n/**\n * Adds API Gateway integrations and auth to the given operation\n */\nconst applyMethodIntegration = (\n  path: string,\n  method: Method,\n  {\n    integrations,\n    corsOptions,\n    apiKeyOptions,\n    defaultAuthorizerReference,\n  }: PrepareApiSpecOptions,\n  operation: OpenAPIV3.OperationObject,\n  getOperationName: (methodAndPath: MethodAndPath) => string\n): OpenAPIV3.OperationObject | undefined => {\n  const operationName = getOperationName({ method, path });\n  if (!(operationName in integrations)) {\n    throw new Error(\n      `Missing required integration for operation ${operationName} (${method} ${path})`\n    );\n  }\n\n  let { methodAuthorizer, integration, options } =\n    integrations[operationName as keyof TypeSafeApiIntegrations];\n\n  validateAuthorizerReference(\n    methodAuthorizer,\n    operation.security,\n    operationName\n  );\n\n  let methodApiKeyOptions: AuthorizerApiKeyOptions | undefined = options;\n\n  // When no API key options are present on the method, require the API key if it's\n  // required by default\n  if (!methodApiKeyOptions && apiKeyOptions?.requiredByDefault) {\n    methodApiKeyOptions = { apiKeyRequired: true };\n  }\n\n  // Can only \"require\" an API key if it's in a header, since we only define the security\n  // scheme we'd reference in this case.\n  if (\n    apiKeyOptions?.source !== \"HEADER\" &&\n    methodApiKeyOptions?.apiKeyRequired\n  ) {\n    throw new Error(\n      `Cannot require an API Key when API Key source is not HEADER: ${operationName} (${method} ${path})`\n    );\n  }\n\n  // Apply the default authorizer unless a method authorizer is defined\n  methodAuthorizer = methodAuthorizer ?? defaultAuthorizerReference;\n\n  return {\n    ...operation,\n    responses: Object.fromEntries(\n      Object.entries(operation.responses).map(([statusCode, response]) => [\n        statusCode,\n        {\n          ...response,\n          headers: {\n            ...(corsOptions ? getCorsHeaderDefinitions() : {}),\n            // TODO: Consider following response header references\n            ...(response as OpenAPIV3.ResponseObject).headers,\n          },\n        },\n      ])\n    ),\n    // https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-swagger-extensions-integration.html\n    \"x-amazon-apigateway-integration\": integration,\n    ...applyMethodAuthorizer(methodAuthorizer, methodApiKeyOptions),\n  } as any;\n};\n\nconst getCorsHeaderDefinitions = (): {\n  [name: string]: OpenAPIV3.HeaderObject;\n} => ({\n  \"Access-Control-Allow-Origin\": {\n    schema: { type: \"string\" },\n  },\n  \"Access-Control-Allow-Methods\": {\n    schema: { type: \"string\" },\n  },\n  \"Access-Control-Allow-Headers\": {\n    schema: { type: \"string\" },\n  },\n});\n\nconst generateCorsResponseHeaders = (\n  corsOptions: SerializedCorsOptions\n): { [key: string]: string } => ({\n  \"Access-Control-Allow-Headers\": `'${corsOptions.allowHeaders.join(\",\")}'`,\n  \"Access-Control-Allow-Methods\": `'${corsOptions.allowMethods.join(\",\")}'`,\n  \"Access-Control-Allow-Origin\": `'${corsOptions.allowOrigins.join(\",\")}'`,\n});\n\nexport const generateCorsResponseParameters = (\n  corsOptions: SerializedCorsOptions,\n  prefix: string = \"method.response.header\"\n): { [key: string]: string } =>\n  Object.fromEntries(\n    Object.entries(generateCorsResponseHeaders(corsOptions)).map(\n      ([header, value]) => [`${prefix}.${header}`, value]\n    )\n  );\n\n/**\n * Generates an \"options\" method with no auth to respond with the appropriate headers if cors is enabled\n */\nconst generateCorsOptionsMethod = (\n  pathItem: OpenAPIV3.PathItemObject,\n  { corsOptions }: PrepareApiSpecOptions\n): OpenAPIV3.PathItemObject => {\n  // Do not generate if already manually defined, or cors not enabled\n  if (HttpMethods.OPTIONS in pathItem || !corsOptions) {\n    return {};\n  }\n\n  const statusCode = corsOptions.statusCode;\n\n  return {\n    [HttpMethods.OPTIONS]: {\n      summary: \"CORS Support\",\n      description: \"Enable CORS by returning the correct headers\",\n      responses: {\n        [`${statusCode}`]: {\n          description: \"Default response for CORS method\",\n          headers: getCorsHeaderDefinitions(),\n          content: {},\n        },\n      },\n      // @ts-ignore Ignore apigateway extensions which are not part of default openapi spec type\n      \"x-amazon-apigateway-integration\": {\n        type: \"mock\",\n        requestTemplates: {\n          \"application/json\": `{\"statusCode\": ${statusCode}}`,\n        },\n        responses: {\n          default: {\n            statusCode: `${statusCode}`,\n            responseParameters: generateCorsResponseParameters(corsOptions),\n            responseTemplates: {\n              \"application/json\": \"{}\",\n            },\n          },\n        },\n      },\n      // No auth for CORS options requests\n      ...noAuthSpecSnippet(),\n    },\n  };\n};\n\nexport const validatePathItem = (\n  path: string,\n  pathItem: OpenAPIV3.PathItemObject\n) => {\n  const supportedPathItemKeys = new Set<string>([\n    // https://spec.openapis.org/oas/v3.0.3#path-item-object\n    ...Object.values(HttpMethods),\n    \"summary\",\n    \"description\",\n    \"parameters\",\n    \"servers\",\n    // All $refs should be resolved already, so we'll error if one remains somehow\n  ]);\n  const unsupportedMethodsInSpec = Object.keys(pathItem).filter(\n    (method) => !supportedPathItemKeys.has(method)\n  );\n  if (unsupportedMethodsInSpec.length > 0) {\n    throw new Error(\n      `Path ${path} contains unsupported method${\n        unsupportedMethodsInSpec.length > 1 ? \"s\" : \"\"\n      } ${unsupportedMethodsInSpec.join(\n        \", \"\n      )}. Supported methods are ${Object.values(HttpMethods).join(\", \")}.`\n    );\n  }\n};\n\n/**\n * Prepares a given api path by adding integrations, configuring auth\n */\nconst preparePathSpec = (\n  path: string,\n  pathItem: OpenAPIV3.PathItemObject,\n  options: PrepareApiSpecOptions,\n  getOperationName: (methodAndPath: MethodAndPath) => string\n): OpenAPIV3.PathItemObject => {\n  validatePathItem(path, pathItem);\n\n  return {\n    ...pathItem,\n    ...Object.fromEntries(\n      Object.values(HttpMethods)\n        .filter((method) => pathItem[method])\n        .map((method) => [\n          method,\n          applyMethodIntegration(\n            path,\n            method,\n            options,\n            pathItem[method]!,\n            getOperationName\n          ),\n        ])\n    ),\n    // Generate an 'options' method required for CORS preflight requests if cors is enabled\n    ...generateCorsOptionsMethod(pathItem, options),\n  };\n};\n\n/**\n * Return whether the given OpenAPI object is a reference object\n */\nconst isRef = (obj: any): obj is OpenAPIV3.ReferenceObject => \"$ref\" in obj;\n\n/**\n * Validate the construct security schemes against the security schemes in the original spec.\n * Construct-defined authorizers always override those in the spec if they have the same ID, however we validate that\n * we are not overriding an authorizer of a different type to avoid mistakes/mismatches between the spec and the\n * construct.\n * @param constructSecuritySchemes security schemes generated from the construct authorizers\n * @param existingSpecSecuritySchemes security schemes already defined in the spec\n */\nconst validateSecuritySchemes = (\n  constructSecuritySchemes: { [key: string]: OpenAPIV3.SecuritySchemeObject },\n  existingSpecSecuritySchemes?: {\n    [key: string]: OpenAPIV3.SecuritySchemeObject | OpenAPIV3.ReferenceObject;\n  }\n) => {\n  if (existingSpecSecuritySchemes) {\n    const constructSecuritySchemeIds = new Set(\n      Object.keys(constructSecuritySchemes)\n    );\n    const existingSecuritySchemeIds = new Set(\n      Object.keys(existingSpecSecuritySchemes)\n    );\n\n   