@byaga/cdk-patterns 0.11.5 → 0.11.6

package/archive/DynamoDbTable.ts

@@ -1,40 +0,0 @@
-import {CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
-import {Table, BillingMode, AttributeType} from 'aws-cdk-lib/aws-dynamodb'
-import {Effect, Policy, PolicyStatement} from "aws-cdk-lib/aws-iam";
-import {DeployStack} from "./DeployStack"
-
-interface DynamoDbTableConfig {
-    partitionKey: string,
-    sortKey?: string
-}
-
-export class DynamoDbTable extends Table {
-    getPolicy: Policy
-
-    constructor(stack: DeployStack, id: string, props: DynamoDbTableConfig) {
-        console.log('Creating DynamoDb Table', stack.genName(id, 'data-table'))
-        super(stack, stack.genId(id, 'data-table'), {
-            tableName: stack.genName(id, 'data-table'),
-            partitionKey: {name: props.partitionKey, type: AttributeType.STRING},
-            sortKey: props.sortKey ? {name: props.sortKey, type: AttributeType.STRING} : undefined,
-            billingMode: BillingMode.PAY_PER_REQUEST,
-            removalPolicy: RemovalPolicy.DESTROY
-        });
-    stack.set('dynamo', id, this)
-
-        new CfnOutput(stack, stack.genId(id, 'table'), {
-            value: this.tableName,
-            exportName: stack.genName(id, 'table')
-        })
-
-        this.getPolicy = new Policy(stack, stack.genId(id, 'get-policy'), {
-            statements: [
-                new PolicyStatement({
-                    actions: ['dynamodb:GetItem'],
-                    effect: Effect.ALLOW,
-                    resources: [this.tableArn]
-                })
-            ]
-        })
-    }
-}

package/archive/ICorsConfig.ts

@@ -1,5 +0,0 @@
-export interface ICorsConfig {
-    maxAge?: number
-    exposeHeaders?: string[],
-    allowOrigin?: string|string[]
-}

package/archive/IDomainConfig.ts

@@ -1,8 +0,0 @@
-import IHostedZoneConfig from "./IHostedZoneConfig";
-
-export interface IDomainConfig {
-    domainName: string,
-    subdomain?: string,
-    hostedZone: IHostedZoneConfig
-}
-export default IDomainConfig

package/archive/IHostedZoneConfig.ts

@@ -1,5 +0,0 @@
-export interface IHostedZoneConfig {
-    name: string,
-    id: string
-}
-export default IHostedZoneConfig

package/archive/NodeJsLambdaLayer.ts

@@ -1,42 +0,0 @@
-import {Code, LayerVersion, Runtime} from "aws-cdk-lib/aws-lambda";
-import {DeployStack} from "./DeployStack";
-import {LayerVersionOptions} from "aws-cdk-lib/aws-lambda/lib/layers";
-import {Architecture} from "aws-cdk-lib/aws-lambda/lib/architecture";
-import {buildNodeSource} from "./methods/build-node-source";
-import duration from "./methods/duration";
-
-/**
- * Interface for the properties of the NodeJsLambdaLayer class.
- */
-interface NodeJsLambdaLayerProps extends LayerVersionOptions {
-    readonly compatibleRuntimes?: Runtime[];
-    readonly compatibleArchitectures?: Architecture[];
-}
-
-/**
- * Class representing a Node.js AWS Lambda layer.
- * Extends the LayerVersion class from the AWS CDK library.
- */
-export class NodeJsLambdaLayer extends LayerVersion {
-    /**
-     * Constructs a new NodeJsLambdaLayer instance.
-     * @param {DeployStack} stack - The deployment stack.
-     * @param {string} id - The ID of the layer.
-     * @param {NodeJsLambdaLayerProps} props - The properties of the layer.
-     */
-    constructor(stack: DeployStack, id: string, props: NodeJsLambdaLayerProps = {}) {
-        console.log("Building Lambda Layer", id);
-        const done = duration()
-        const buildDir = buildNodeSource('lambda-layer', id, {subdirectory:'nodejs'})
-        console.log('Build Duration (ms)', done())
-
-        super(stack, stack.genId(id), {
-            compatibleRuntimes: [Runtime.NODEJS_20_X],
-            ...props,
-            layerVersionName: stack.genName(id),
-            code: Code.fromAsset(buildDir),
-
-        });
-        stack.set('lambda-layer', id, this)
-    }
-}

package/archive/Output.ts

@@ -1,11 +0,0 @@
-import {CfnOutput} from 'aws-cdk-lib/core';
-import {DeployStack} from './DeployStack';
-
-export class Output extends CfnOutput {
-    constructor(stack: DeployStack, name: string, value: string) {
-        super(stack, stack.genId(name, 'output'), {
-            value,
-            exportName: stack.genName(name)
-        })
-    }
-}

package/archive/RestApi.ts

@@ -1,180 +0,0 @@
-import {
-    BasePathMapping,
-    ContentHandling,
-    DomainName,
-    EndpointType,
-    IDomainName,
-    IResource,
-    MockIntegration,
-    RestApi as RestApiBase
-} from "aws-cdk-lib/aws-apigateway";
-import {DeployStack} from "./DeployStack"
-import {ICorsConfig} from "./ICorsConfig";
-import {Duration, Size} from "aws-cdk-lib";
-import {Effect, Policy, PolicyStatement, Role} from "aws-cdk-lib/aws-iam";
-
-interface IRestApiConfig {
-    cors?: ICorsConfig,
-    allowCredentials: boolean
-}
-
-interface IBasePathMappingConfig {
-    domain?: IDomainName,
-    domainName?: string,
-    hostedZoneId?: string
-}
-
-interface IResourceNode {
-    children: { [key: string]: IResourceNode }
-    node: IResource
-}
-
-const DEFAULT_EXPOSE_HEADERS = ['Date']
-
-export class RestApi extends RestApiBase {
-    _id: string
-    _tree: IResourceNode
-
-
-    constructor(stack: DeployStack, id: string, props: IRestApiConfig) {
-        const {stage} = stack
-
-        console.log('Defining Rest API', stack.genId(id, 'api'))
-
-        const cors: ICorsConfig = props.cors || {}
-        const allowOrigins: string[] = Array.isArray(cors.allowOrigin) ? cors.allowOrigin : [cors.allowOrigin || '*']
-        super(stack, stack.genId(id, 'api'), {
-            restApiName: stack.genName('api'),
-            deploy: true,
-            deployOptions: {
-                stageName: stage,
-                tracingEnabled: true
-            },
-            minCompressionSize: Size.bytes(1000),
-            endpointConfiguration: {
-                types: [EndpointType.EDGE]
-            },
-            defaultCorsPreflightOptions: {
-                allowHeaders: ['*'],
-                allowMethods: ['*'],
-                allowCredentials: props.allowCredentials,
-                allowOrigins,
-                maxAge: Duration.seconds(cors.maxAge || 86400),
-                exposeHeaders: cors.exposeHeaders || DEFAULT_EXPOSE_HEADERS
-            }
-        })
-        this._id = id
-
-        // APIs MUST have at least one endpoint, so this will give it one
-        console.log('Adding health endpoint', '/health')
-        const health = this.root.addResource('health')
-        health.addMethod("GET", new MockIntegration({
-            requestTemplates: {
-                "application/json": "{\"statusCode\": 200}"
-            },
-            integrationResponses: [{
-                statusCode: '200',
-                contentHandling: ContentHandling.CONVERT_TO_TEXT,
-                responseTemplates: {
-                    'application/json': `
-##  See http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
-##  This template will pass through all parameters including path, querystring, header, stage variables, and context through to the integration endpoint via the body/payload
-#set($allParams = $input.params())
-{
-"body-json" : $input.json('$'),
-"params" : {
-#foreach($type in $allParams.keySet())
-    #set($params = $allParams.get($type))
-"$type" : {
-    #foreach($paramName in $params.keySet())
-    "$paramName" : "$util.escapeJavaScript($params.get($paramName))"
-        #if($foreach.hasNext),#end
-    #end
-}
-    #if($foreach.hasNext),#end
-#end
-},
-"stage-variables" : {
-#foreach($key in $stageVariables.keySet())
-"$key" : "$util.escapeJavaScript($stageVariables.get($key))"
-    #if($foreach.hasNext),#end
-#end
-},
-"context" : {
-    "account-id" : "$context.identity.accountId",
-    "api-id" : "$context.apiId",
-    "api-key" : "$context.identity.apiKey",
-    "authorizer-principal-id" : "$context.authorizer.principalId",
-    "caller" : "$context.identity.caller",
-    "cognito-authentication-provider" : "$context.identity.cognitoAuthenticationProvider",
-    "cognito-authentication-type" : "$context.identity.cognitoAuthenticationType",
-    "cognito-identity-id" : "$context.identity.cognitoIdentityId",
-    "cognito-identity-pool-id" : "$context.identity.cognitoIdentityPoolId",
-    "http-method" : "$context.httpMethod",
-    "stage" : "$context.stage",
-    "source-ip" : "$context.identity.sourceIp",
-    "user" : "$context.identity.user",
-    "user-agent" : "$context.identity.userAgent",
-    "user-arn" : "$context.identity.userArn",
-    "request-id" : "$context.requestId",
-    "resource-id" : "$context.resourceId",
-    "resource-path" : "$context.resourcePath"
-    }
-}`
-                }
-            }]
-        }), {
-            methodResponses: [{statusCode: "200"}]
-        })
-
-        this._tree = {node: this.root, children: {}}
-    }
-
-    addBasePathMapping(stack: DeployStack, config: IBasePathMappingConfig) {
-        let domain = config.domain
-        if (!domain && config.domainName && config.hostedZoneId) {
-            domain = DomainName.fromDomainNameAttributes(stack, stack.genName('domain-name'), {
-                domainName: config.domainName,
-                domainNameAliasHostedZoneId: config.hostedZoneId,
-                domainNameAliasTarget: this.restApiRootResourceId
-            })
-        }
-        if (!domain) throw new Error('Missing Domain Configuration For Base Path Mapping')
-
-        new BasePathMapping(stack, stack.genId(this._id, 'base-path-mapping'), {
-            domainName: domain,
-            stage: this.deploymentStage,
-            restApi: this,
-            basePath: this._id
-        })
-    }
-
-    addAuthorizedRole(stack: DeployStack, roleArn: string): PolicyStatement {
-        const policyStatement = new PolicyStatement({
-            effect: Effect.ALLOW,
-            actions: ['execute-api:Invoke']
-        })
-
-        const authRole = Role.fromRoleArn(stack, stack.genId('authenticated-role'), roleArn)
-        authRole.attachInlinePolicy(new Policy(stack, stack.genId('api-access-policy'), {
-            statements: [policyStatement]
-        }))
-        return policyStatement;
-    }
-
-    path(uri: string): IResource {
-        const {node} = uri.split('/')
-            .filter(path => !!path)
-            .reduce((resource, path) => {
-                if (!resource.children[path]) {
-                    resource.children[path] = {
-                        children: {},
-                        node: resource.node.addResource(path)
-                    }
-                }
-                return resource.children[path];
-            }, this._tree);
-
-        return node
-    }
-}

package/archive/Role.ts

@@ -1,165 +0,0 @@
-import {FederatedPrincipal, IPrincipal, Role as CdkRole} from "aws-cdk-lib/aws-iam";
-import {Duration} from "aws-cdk-lib";
-import {Output} from './Output'
-import {DeployStack} from "./DeployStack";
-import {IManagedPolicy} from "aws-cdk-lib/aws-iam/lib/managed-policy";
-import {PolicyDocument} from "aws-cdk-lib/aws-iam/lib/policy-document";
-
-interface IRoleProps {
-    identityPool: string,
-    amr: string,
-    /**
-     * The IAM principal (i.e. `new ServicePrincipal('sns.amazonaws.com')`) which can assume this role.
-     *
-     * You can later modify the assume role policy document by accessing it via
-     * the `assumeRolePolicy` property.
-     *
-     * @stability stable
-     */
-    assumedBy?: IPrincipal,
-
-    /**
-     * (deprecated) ID that the role assumer needs to provide when assuming this role.
-     *
-     * If the configured and provided external IDs do not match, the
-     * AssumeRole operation will fail.
-     *
-     * @default No external ID required
-     * @deprecated see {@link externalIds}
-     */
-    readonly externalId?: string;
-    /**
-     * List of IDs that the role assumer needs to provide one of when assuming this role.
-     *
-     * If the configured and provided external IDs do not match, the
-     * AssumeRole operation will fail.
-     *
-     * @default No external ID required
-     * @stability stable
-     */
-    readonly externalIds?: string[];
-    /**
-     * A list of managed policies associated with this role.
-     *
-     * You can add managed policies later using
-     * `addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName(policyName))`.
-     *
-     * @default - No managed policies.
-     * @stability stable
-     */
-    readonly managedPolicies?: IManagedPolicy[];
-    /**
-     * A list of named policies to inline into this role.
-     *
-     * These policies will be
-     * created with the role, whereas those added by ``addToPolicy`` are added
-     * using a separate CloudFormation resource (allowing a way around circular
-     * dependencies that could otherwise be introduced).
-     *
-     * @default - No policy is inlined in the Role resource.
-     * @stability stable
-     */
-    readonly inlinePolicies?: {
-        [name: string]: PolicyDocument;
-    };
-    /**
-     * The path associated with this role.
-     *
-     * For information about IAM paths, see
-     * Friendly Names and Paths in IAM User Guide.
-     *
-     * @default /
-     * @stability stable
-     */
-    readonly path?: string;
-    /**
-     * AWS supports permissions boundaries for IAM entities (users or roles).
-     *
-     * A permissions boundary is an advanced feature for using a managed policy
-     * to set the maximum permissions that an identity-based policy can grant to
-     * an IAM entity. An entity's permissions boundary allows it to perform only
-     * the actions that are allowed by both its identity-based policies and its
-     * permissions boundaries.
-     *
-     * @default - No permissions boundary.
-     * @stability stable
-     * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html
-     */
-    readonly permissionsBoundary?: IManagedPolicy;
-    /**
-     * A name for the IAM role.
-     *
-     * For valid values, see the RoleName parameter for
-     * the CreateRole action in the IAM API Reference.
-     *
-     * IMPORTANT: If you specify a name, you cannot perform updates that require
-     * replacement of this resource. You can perform updates that require no or
-     * some interruption. If you must replace the resource, specify a new name.
-     *
-     * If you specify a name, you must specify the CAPABILITY_NAMED_IAM value to
-     * acknowledge your template's capabilities. For more information, see
-     * Acknowledging IAM Resources in AWS CloudFormation Templates.
-     *
-     * @default - AWS CloudFormation generates a unique physical ID and uses that ID
-     * for the role name.
-     * @stability stable
-     */
-    readonly roleName?: string;
-    /**
-     * The maximum session duration that you want to set for the specified role.
-     *
-     * This setting can have a value from 1 hour (3600sec) to 12 (43200sec) hours.
-     *
-     * Anyone who assumes the role from the AWS CLI or API can use the
-     * DurationSeconds API parameter or the duration-seconds CLI parameter to
-     * request a longer session. The MaxSessionDuration setting determines the
-     * maximum duration that can be requested using the DurationSeconds
-     * parameter.
-     *
-     * If users don't specify a value for the DurationSeconds parameter, their
-     * security credentials are valid for one hour by default. This applies when
-     * you use the AssumeRole* API operations or the assume-role* CLI operations
-     * but does not apply when you use those operations to create a console URL.
-     *
-     * @default Duration.hours(1)
-     * @stability stable
-     * @link https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html
-     */
-    readonly maxSessionDuration?: Duration;
-    /**
-     * A description of the role.
-     *
-     * It can be up to 1000 characters long.
-     *
-     * @default - No description.
-     * @stability stable
-     */
-    readonly description?: string;
-}
-
-export class Role extends CdkRole {
-    constructor(stack: DeployStack, id: string, props: IRoleProps) {
-        console.log('Defining Role', stack.genId(id))
-        if (!props.assumedBy) {
-            props.assumedBy = new FederatedPrincipal(
-                'cognito-identity.amazonaws.com',
-                {
-                    StringEquals: {
-                        'cognito-identity.amazonaws.com:aud': props.identityPool
-                    },
-                    "ForAnyValue:StringLike": {
-                        'cognito-identity.amazonaws.com:amr': props.amr
-                    }
-                },
-                'sts:AssumeRoleWithWebIdentity'
-            )
-        }
-
-        super(stack, stack.genId(id), {
-            ...props,
-            roleName: stack.genName(props.roleName || id),
-            assumedBy: props.assumedBy
-        })
-        new Output(stack, `${id}-arn`, this.roleArn)
-    }
-}

package/archive/StaticWebSite.ts

@@ -1,158 +0,0 @@
-import {RemovalPolicy} from "aws-cdk-lib/core";
-import {Output} from './Output'
-import {DeployStack} from "./DeployStack";
-import {execSync} from "child_process";
-import {Bucket} from "aws-cdk-lib/aws-s3"
-import {BucketDeployment, Source} from "aws-cdk-lib/aws-s3-deployment"
-import ApiCertificate from "./ApiCertificate";
-import {
-    CloudFrontAllowedMethods,
-    CloudFrontWebDistribution,
-    OriginAccessIdentity,
-    OriginProtocolPolicy, SourceConfiguration,
-    SSLMethod,
-    ViewerCertificate,
-    ViewerProtocolPolicy
-} from "aws-cdk-lib/aws-cloudfront"
-import IDomainConfig from "./IDomainConfig";
-import {PolicyStatement} from "aws-cdk-lib/aws-iam";
-import {ARecord, RecordTarget} from "aws-cdk-lib/aws-route53";
-import {CloudFrontTarget} from "aws-cdk-lib/aws-route53-targets";
-import duration from './methods/duration';
-import {buildNodeSource} from './methods/build-node-source'
-import {Duration} from "aws-cdk-lib";
-
-/**
- * Configuration interface for the StaticWebSite class.
- */
-export interface StaticWebSiteConfig {
-    srcDir?: string,
-    domain: IDomainConfig,
-    env: NodeJS.ProcessEnv,
-    proxy?: SourceConfiguration[]
-}
-
-/**
- * Logic which will setup a static web site in AWS with an S3 Bucket, CloudFront Distribution, and Route53 A-Name Record.
- */
-export class StaticWebSite {
-    /**
-     * Constructs a new StaticWebSite instance.
-     * @param {DeployStack} stack - The deployment stack.
-     * @param {string} id - The ID of the website.
-     * @param {StaticWebSiteConfig} props - The configuration properties of the website.
-     */
-    constructor(stack: DeployStack, id: string, props: StaticWebSiteConfig) {
-        console.log('Deploying Static Web Site', id)
-
-        const done = duration()
-        const buildDir = buildNodeSource('web', id)
-
-        console.log('Building UI Source', id)
-        execSync('npm run export', {
-                cwd: buildDir,
-                env: props.env
-        })
-
-        console.log('Total Build Duration (ms)', done())
-        const exportDir: string = buildDir + '/out';
-
-        console.log('Creating HTTPS Certificate', id + '-certificate')
-        const certificate = new ApiCertificate(stack, id + '-certificate', props.domain);
-        console.log('Deploying Site Content Bucket', stack.genId(id, "content-bucket"))
-        const s3BucketSource = new Bucket(stack, stack.genId(id, "content-bucket"), {
-            bucketName: certificate.domain,
-            websiteIndexDocument: "index.html",
-            websiteErrorDocument: "error.html",
-            removalPolicy: RemovalPolicy.DESTROY,
-            autoDeleteObjects: true,
-            publicReadAccess: false,
-            blockPublicAccess: {
-                blockPublicAcls: true,
-                blockPublicPolicy: true,
-                ignorePublicAcls: true,
-                restrictPublicBuckets: true
-            }
-        });
-        new Output(stack, `${id}-content-bucket`, s3BucketSource.bucketName);
-
-        const cloudFrontPolicy = new PolicyStatement({
-            actions: ['s3:GetBucket*', 's3:GetObject*', 's3:List*'],
-            resources: [s3BucketSource.bucketArn, s3BucketSource.bucketArn + '/*'],
-        })
-
-        new BucketDeployment(stack, stack.genId(id, 'bucket-deployment'), {
-            sources: [Source.asset(exportDir)],
-            destinationBucket: s3BucketSource
-        })
-        const originAccessIdentity = new OriginAccessIdentity(stack, "WebsiteOAI");
-         cloudFrontPolicy.addArnPrincipal(originAccessIdentity.cloudFrontOriginAccessIdentityS3CanonicalUserId);
-         s3BucketSource.grantRead(originAccessIdentity)
-
-        const distro = new CloudFrontWebDistribution(stack, stack.genId(id, 'cloudfront-web-distribution'), {
-            enabled: true,
-             originConfigs: [...props.proxy || [], {
-                 s3OriginSource: {
-                     s3BucketSource,
-                     originAccessIdentity
-                 },
-                 behaviors: [{
-                     allowedMethods: CloudFrontAllowedMethods.GET_HEAD_OPTIONS,
-                     isDefaultBehavior: true
-                 }]
-             }],
-            viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-            viewerCertificate: ViewerCertificate.fromAcmCertificate(certificate, {
-                aliases: [certificate.domain],
-                sslMethod: SSLMethod.SNI
-            })
-        })
-        new Output(stack, `${id}-base-url`, "https://" + certificate.domain);
-
-        console.log('Setting Route53 A-Name Record', props.domain.domainName)
-         new ARecord(stack, stack.genId('alias'), {
-             zone: certificate.hostedZone,
-             recordName: certificate.domain,
-             target: RecordTarget.fromAlias(new CloudFrontTarget(distro))
-         })
-    }
-
-    /**
-     * Defines a proxy for the static website.
-     * @param {DeployStack} stack - The deployment stack.
-     * @param {string} domainName - The domain name.
-     * @param {string} pathPattern - The path pattern.
-     * @returns {SourceConfiguration} The source configuration for the proxy.
-     */
-    static defineProxy(stack: DeployStack, domainName: string, pathPattern: string): SourceConfiguration {
-        return {
-            customOriginSource: {
-                domainName: domainName,
-                originPath:  `/${stack.stage}`,
-                originProtocolPolicy: OriginProtocolPolicy.HTTPS_ONLY
-            },
-            behaviors: [{
-                pathPattern,
-                allowedMethods: CloudFrontAllowedMethods.ALL,
-                maxTtl: Duration.seconds(0),
-                minTtl: Duration.seconds(0),
-                defaultTtl: Duration.seconds(0),
-                compress: false,
-                forwardedValues: {
-                    queryString: true,
-                    headers: [
-                        "Authorization",
-                        "User-Agent",
-                        "X-Trace-Id",
-                        "X-Span-Id",
-                        "X-Correlation-Id",
-                        'Referer',
-                        "User-Agent",
-                        "Accept-Language",
-                        'Content-Type',
-                        'Content-Length'
-                    ]
-                }
-            }]
-        }    }
-}

package/archive/index.ts

@@ -1,18 +0,0 @@
-export {ApiCertificate} from "./ApiCertificate";
-export {CognitoApiGatewayAuthorizer} from "./CognitoApiGatewayAuthorizer";
-export {DeployStack} from "./DeployStack";
-export {DynamoDbTable} from "./DynamoDbTable";
-export {IHostedZoneConfig} from "./IHostedZoneConfig";
-export {IDomainConfig} from "./IDomainConfig";
-export {IStackArguments} from "./IStackArguments";
-export {NodeJsLambdaLayer} from "./NodeJsLambdaLayer";
-export {Output} from "./Output";
-export {RestApi} from "./RestApi";
-export {Role} from "./Role";
-export {SsmParameter} from "./SsmParameter";
-export {StaticWebSite} from "./StaticWebSite";
-
-export {createFunction} from "./create-function";
-export {createNodejsLambda} from "./create-nodejs-lambda";
-export {attachFunctionToApi} from "./methods/attach-function-to-api";
-export {applySchemaToMethodOptions} from "./methods/apply-schema-to-method-options";

package/archive/methods/apply-schema-to-method-options.ts

@@ -1,38 +0,0 @@
-import {DeployStack} from "../DeployStack";
-import {
-    JsonSchema,
-    MethodOptions,
-    Model,
-    RequestValidator,
-    IResource
-} from "aws-cdk-lib/aws-apigateway";
-
-/**
- * Applies a schema to a method.
- * @param {DeployStack} stack - The deployment stack.
- * @param {string} name - The name of the method.
- * @param {JsonSchema} schema - The schema.
- * @param {MethodOptions} options - The method options.
- * @param {IResource} path - The path.
- * @returns {MethodOptions} The method options with the schema applied.
- */
-export function applySchemaToMethodOptions(stack: DeployStack, name: string, schema: JsonSchema, options: MethodOptions, path: IResource): MethodOptions {
-    return {
-        ...options,
-        requestValidator: new RequestValidator(stack, stack.genId(name, 'validator'), {
-            restApi: path.api,
-            requestValidatorName: stack.genName(name, 'validator'),
-            validateRequestBody: true
-        }),
-        requestModels: {
-            'application/json': new Model(stack, stack.genId(name, 'model'), {
-                schema: schema,
-                contentType: 'application/json',
-                restApi: path.api,
-                modelName: stack.genId(name, 'model')
-            })
-        }
-    }
-}
-
-export default applySchemaToMethodOptions;