@macedon-technologies/batman 1.0.16

package/lib/StaticWebsiteConstructFile.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticWebsiteConstructFile = void 0;
+const projen_1 = require("projen");
+class StaticWebsiteConstructFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'src/constructs/StaticWebsite.ts', {
+            contents: `import * as path from 'path';
+import { DockerImage, Duration, RemovalPolicy } from 'aws-cdk-lib';
+import { RestApi } from 'aws-cdk-lib/aws-apigateway';
+import { Certificate, CertificateValidation } from 'aws-cdk-lib/aws-certificatemanager';
+import {
+  AllowedMethods,
+  CacheHeaderBehavior,
+  CachePolicy,
+  Distribution,
+  ViewerProtocolPolicy,
+} from 'aws-cdk-lib/aws-cloudfront';
+import { RestApiOrigin, S3BucketOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';
+import { PolicyStatement, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
+import { ARecord, IHostedZone, RecordTarget } from 'aws-cdk-lib/aws-route53';
+import { CloudFrontTarget } from 'aws-cdk-lib/aws-route53-targets';
+import { BlockPublicAccess, Bucket, BucketAccessControl } from 'aws-cdk-lib/aws-s3';
+import { BucketDeployment, Source } from 'aws-cdk-lib/aws-s3-deployment';
+import { Construct } from 'constructs';
+
+export interface StaticWebsiteProps {
+  readonly bucketName?: string;
+  readonly hostedZone: IHostedZone;
+  readonly api: RestApi;
+  readonly hostname?: string;
+}
+
+export class StaticWebsite extends Construct {
+  public bucket: Bucket;
+  public distribution: Distribution;
+  public certificate: Certificate;
+
+  private apiCachePolicy: CachePolicy;
+  private aRecord: ARecord;
+  private bucketDeployment: BucketDeployment;
+  private hostname: string;
+
+  constructor(scope: Construct, id: string, private props: StaticWebsiteProps) {
+    super(scope, id);
+
+    const domainName = props.hostedZone.zoneName;
+    const hostname = props.hostname || 'mvp';
+    this.hostname = \`\${hostname}.\${domainName}\`;
+
+    this.createCertificate();
+    if (!this.certificate) {
+      throw new Error('Failed to create certificate');
+    }
+
+    this.createBucket();
+    if (!this.bucket) {
+      throw new Error('Failed to create bucket');
+    }
+
+    this.createApiCachePolicy();
+    if (!this.apiCachePolicy) {
+      throw new Error('Failed to create API cache policy');
+    }
+
+    this.createDistribution();
+    if (!this.distribution) {
+      throw new Error('Failed to create distribution');
+    }
+
+    this.createDnsRecord();
+    if (!this.aRecord) {
+      throw new Error('Failed to create DNS A record');
+    }
+
+    this.addBucketPolicy();
+    this.createBucketDeployment();
+    if (!this.bucketDeployment) {
+      throw new Error('Failed to create bucket deployment');
+    }
+  }
+
+  protected createCertificate() {
+    this.certificate = new Certificate(this, 'Certificate', {
+      domainName: this.hostname,
+      validation: CertificateValidation.fromDns(this.props.hostedZone),
+    });
+  }
+
+  protected createBucket() {
+    this.bucket = new Bucket(this, 'Bucket', {
+      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
+      accessControl: BucketAccessControl.PRIVATE,
+      removalPolicy: RemovalPolicy.DESTROY,
+      autoDeleteObjects: true,
+    });
+  }
+
+  protected createApiCachePolicy() {
+    this.apiCachePolicy = new CachePolicy(this, 'ApiCachePolicy', {
+      comment: 'Cache policy for API Gateway with dynamic content',
+      defaultTtl: Duration.seconds(0),
+      maxTtl: Duration.seconds(1),
+      minTtl: Duration.seconds(0),
+      enableAcceptEncodingBrotli: true,
+      enableAcceptEncodingGzip: true,
+      headerBehavior: CacheHeaderBehavior.allowList('Authorization'),
+    });
+  }
+
+  protected createDistribution() {
+    this.distribution = new Distribution(this, 'Distribution', {
+      domainNames: [this.hostname],
+      certificate: this.certificate,
+      defaultBehavior: {
+        origin: S3BucketOrigin.withOriginAccessControl(this.bucket),
+        viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+      },
+      additionalBehaviors: {
+        '/api/*': {
+          origin: new RestApiOrigin(this.props.api),
+          viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+          allowedMethods: AllowedMethods.ALLOW_ALL,
+          cachePolicy: this.apiCachePolicy,
+
+        },
+      },
+      defaultRootObject: 'index.html',
+      errorResponses: [
+        {
+          httpStatus: 404,
+          responsePagePath: '/index.html',
+        },
+        {
+          httpStatus: 403,
+          responsePagePath: '/index.html',
+        },
+      ],
+    });
+  }
+
+  protected createDnsRecord() {
+    this.aRecord = new ARecord(this, 'ARecord', {
+      zone: this.props.hostedZone,
+      recordName: this.hostname,
+      target: RecordTarget.fromAlias(new CloudFrontTarget(this.distribution)),
+    });
+  }
+
+  protected addBucketPolicy() {
+    this.bucket.addToResourcePolicy(
+      new PolicyStatement({
+        sid: 'AllowCloudFrontServicePrincipal',
+        actions: ['s3:GetObject'],
+        resources: [\`\${this.bucket.bucketArn}/*\`],
+        principals: [new ServicePrincipal('cloudfront.amazonaws.com')],
+        conditions: {
+          StringEquals: {
+            'AWS:SourceArn': \`arn:aws:cloudfront::\${this.bucket.stack.account}:distribution/\${this.distribution.distributionId}\`,
+          },
+        },
+      }),
+    );
+  }
+
+  protected createBucketDeployment() {
+    this.bucketDeployment = new BucketDeployment(this, 'BucketDeployment', {
+      sources: [Source.asset(path.join(__dirname, '../..'), {
+        bundling: {
+          image: DockerImage.fromRegistry('node:20-alpine'),
+          environment: {
+            npm_config_cache: '/tmp/.npm',
+          },
+          command: [
+            'sh',
+            '-c',
+            [
+              'cd /asset-input/web',
+              'yarn install --frozen-lockfile --cache-folder /tmp/.yarn',
+              'yarn build',
+              \`sed -i 's|"apiBaseUrl": "[^"]*"|"apiBaseUrl": "https://\${this.hostname}/api"|g' dist/config.json\`,
+              'cp -r dist/* /asset-output/',
+            ].join(' && '),
+          ],
+        },
+      })],
+      destinationBucket: this.bucket,
+      distribution: this.distribution,
+      distributionPaths: ['/*'],
+    });
+  }
+}
+`,
+        });
+    }
+}
+exports.StaticWebsiteConstructFile = StaticWebsiteConstructFile;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StaticWebsiteConstructFile.js","sourceRoot":"","sources":["../src/StaticWebsiteConstructFile.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AAGpC,MAAa,0BAA2B,SAAQ,mBAAU;IACxD,YAAY,OAA4B;QACtC,KAAK,CAAC,OAAO,EAAE,iCAAiC,EAAE;YAChD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyLf;SACI,CAAC,CAAC;IACL,CAAC;CACF;AA/LD,gEA+LC","sourcesContent":["import { SampleFile } from 'projen';\nimport { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';\n\nexport class StaticWebsiteConstructFile extends SampleFile {\n  constructor(project: AwsCdkTypeScriptApp) {\n    super(project, 'src/constructs/StaticWebsite.ts', {\n      contents: `import * as path from 'path';\nimport { DockerImage, Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport { RestApi } from 'aws-cdk-lib/aws-apigateway';\nimport { Certificate, CertificateValidation } from 'aws-cdk-lib/aws-certificatemanager';\nimport {\n  AllowedMethods,\n  CacheHeaderBehavior,\n  CachePolicy,\n  Distribution,\n  ViewerProtocolPolicy,\n} from 'aws-cdk-lib/aws-cloudfront';\nimport { RestApiOrigin, S3BucketOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';\nimport { PolicyStatement, ServicePrincipal } from 'aws-cdk-lib/aws-iam';\nimport { ARecord, IHostedZone, RecordTarget } from 'aws-cdk-lib/aws-route53';\nimport { CloudFrontTarget } from 'aws-cdk-lib/aws-route53-targets';\nimport { BlockPublicAccess, Bucket, BucketAccessControl } from 'aws-cdk-lib/aws-s3';\nimport { BucketDeployment, Source } from 'aws-cdk-lib/aws-s3-deployment';\nimport { Construct } from 'constructs';\n\nexport interface StaticWebsiteProps {\n  readonly bucketName?: string;\n  readonly hostedZone: IHostedZone;\n  readonly api: RestApi;\n  readonly hostname?: string;\n}\n\nexport class StaticWebsite extends Construct {\n  public bucket: Bucket;\n  public distribution: Distribution;\n  public certificate: Certificate;\n\n  private apiCachePolicy: CachePolicy;\n  private aRecord: ARecord;\n  private bucketDeployment: BucketDeployment;\n  private hostname: string;\n\n  constructor(scope: Construct, id: string, private props: StaticWebsiteProps) {\n    super(scope, id);\n\n    const domainName = props.hostedZone.zoneName;\n    const hostname = props.hostname || 'mvp';\n    this.hostname = \\`\\${hostname}.\\${domainName}\\`;\n\n    this.createCertificate();\n    if (!this.certificate) {\n      throw new Error('Failed to create certificate');\n    }\n\n    this.createBucket();\n    if (!this.bucket) {\n      throw new Error('Failed to create bucket');\n    }\n\n    this.createApiCachePolicy();\n    if (!this.apiCachePolicy) {\n      throw new Error('Failed to create API cache policy');\n    }\n\n    this.createDistribution();\n    if (!this.distribution) {\n      throw new Error('Failed to create distribution');\n    }\n\n    this.createDnsRecord();\n    if (!this.aRecord) {\n      throw new Error('Failed to create DNS A record');\n    }\n\n    this.addBucketPolicy();\n    this.createBucketDeployment();\n    if (!this.bucketDeployment) {\n      throw new Error('Failed to create bucket deployment');\n    }\n  }\n\n  protected createCertificate() {\n    this.certificate = new Certificate(this, 'Certificate', {\n      domainName: this.hostname,\n      validation: CertificateValidation.fromDns(this.props.hostedZone),\n    });\n  }\n\n  protected createBucket() {\n    this.bucket = new Bucket(this, 'Bucket', {\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      accessControl: BucketAccessControl.PRIVATE,\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n    });\n  }\n\n  protected createApiCachePolicy() {\n    this.apiCachePolicy = new CachePolicy(this, 'ApiCachePolicy', {\n      comment: 'Cache policy for API Gateway with dynamic content',\n      defaultTtl: Duration.seconds(0),\n      maxTtl: Duration.seconds(1),\n      minTtl: Duration.seconds(0),\n      enableAcceptEncodingBrotli: true,\n      enableAcceptEncodingGzip: true,\n      headerBehavior: CacheHeaderBehavior.allowList('Authorization'),\n    });\n  }\n\n  protected createDistribution() {\n    this.distribution = new Distribution(this, 'Distribution', {\n      domainNames: [this.hostname],\n      certificate: this.certificate,\n      defaultBehavior: {\n        origin: S3BucketOrigin.withOriginAccessControl(this.bucket),\n        viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      },\n      additionalBehaviors: {\n        '/api/*': {\n          origin: new RestApiOrigin(this.props.api),\n          viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n          allowedMethods: AllowedMethods.ALLOW_ALL,\n          cachePolicy: this.apiCachePolicy,\n\n        },\n      },\n      defaultRootObject: 'index.html',\n      errorResponses: [\n        {\n          httpStatus: 404,\n          responsePagePath: '/index.html',\n        },\n        {\n          httpStatus: 403,\n          responsePagePath: '/index.html',\n        },\n      ],\n    });\n  }\n\n  protected createDnsRecord() {\n    this.aRecord = new ARecord(this, 'ARecord', {\n      zone: this.props.hostedZone,\n      recordName: this.hostname,\n      target: RecordTarget.fromAlias(new CloudFrontTarget(this.distribution)),\n    });\n  }\n\n  protected addBucketPolicy() {\n    this.bucket.addToResourcePolicy(\n      new PolicyStatement({\n        sid: 'AllowCloudFrontServicePrincipal',\n        actions: ['s3:GetObject'],\n        resources: [\\`\\${this.bucket.bucketArn}/*\\`],\n        principals: [new ServicePrincipal('cloudfront.amazonaws.com')],\n        conditions: {\n          StringEquals: {\n            'AWS:SourceArn': \\`arn:aws:cloudfront::\\${this.bucket.stack.account}:distribution/\\${this.distribution.distributionId}\\`,\n          },\n        },\n      }),\n    );\n  }\n\n  protected createBucketDeployment() {\n    this.bucketDeployment = new BucketDeployment(this, 'BucketDeployment', {\n      sources: [Source.asset(path.join(__dirname, '../..'), {\n        bundling: {\n          image: DockerImage.fromRegistry('node:20-alpine'),\n          environment: {\n            npm_config_cache: '/tmp/.npm',\n          },\n          command: [\n            'sh',\n            '-c',\n            [\n              'cd /asset-input/web',\n              'yarn install --frozen-lockfile --cache-folder /tmp/.yarn',\n              'yarn build',\n              \\`sed -i 's|\"apiBaseUrl\": \"[^\"]*\"|\"apiBaseUrl\": \"https://\\${this.hostname}/api\"|g' dist/config.json\\`,\n              'cp -r dist/* /asset-output/',\n            ].join(' && '),\n          ],\n        },\n      })],\n      destinationBucket: this.bucket,\n      distribution: this.distribution,\n      distributionPaths: ['/*'],\n    });\n  }\n}\n`,\n    });\n  }\n}\n"]}

package/lib/ViteReactProject.d.ts

@@ -0,0 +1,45 @@
+import { TypeScriptAppProject, TypeScriptProjectOptions } from 'projen/lib/typescript';
+export interface ViteReactProjectOptions extends TypeScriptProjectOptions {
+    /**
+     * Whether to generate sample code
+     * @default true
+     */
+    readonly sampleCode?: boolean;
+    /**
+     * Source directory
+     * @default "src"
+     */
+    readonly srcdir?: string;
+    /**
+     * Public directory for static assets
+     * @default "public"
+     */
+    readonly publicDir?: string;
+    /**
+     * Title for the HTML page
+     * @default project name
+     */
+    readonly title?: string;
+}
+/**
+ * Vite + React TypeScript project
+ */
+export declare class ViteReactProject extends TypeScriptAppProject {
+    readonly srcdir: string;
+    readonly publicDir: string;
+    readonly devCommand: string;
+    private readonly configFields;
+    constructor(options: ViteReactProjectOptions);
+    /**
+     * Add a custom field to the Config type
+     * @param fieldName The name of the field
+     * @param fieldType The TypeScript type of the field (e.g., 'string', 'number', 'boolean', 'string[]')
+     * @returns this project instance for chaining
+     */
+    addConfigField(fieldName: string, fieldType: string): this;
+    /**
+     * Get the config fields map (for internal use by ConfigFile)
+     * @internal
+     */
+    getConfigFields(): Map<string, string>;
+}