@awsless/awsless 0.0.49 → 0.0.51

package/dist/bin.js

@@ -841,20 +841,29 @@ var rollupBundle = ({ format: format2 = "esm", minify = true, handler = "index.d
     const result = await bundle.generate({
       format: format2,
       sourcemap: "hidden",
-      exports: "auto"
+      exports: "auto",
+      manualChunks: {}
     });
-    const output = result.output[0];
-    const code = Buffer.from(output.code, "utf8");
-    const map = output.map ? Buffer.from(output.map.toString(), "utf8") : void 0;
-    const hash = createHash("sha1").update(code).digest("hex");
-    return {
-      handler,
-      hash,
-      files: [{
-        name: format2 === "esm" ? "index.mjs" : "index.js",
+    const hash = createHash("sha1");
+    const files = [];
+    for (const item of result.output) {
+      if (item.type !== "chunk") {
+        continue;
+      }
+      const name = item.isEntry ? format2 === "esm" ? "index.mjs" : "index.js" : item.fileName;
+      const code = Buffer.from(item.code, "utf8");
+      const map = item.map ? Buffer.from(item.map.toString(), "utf8") : void 0;
+      hash.update(code);
+      files.push({
+        name,
         code,
         map
-      }]
+      });
+    }
+    return {
+      handler,
+      hash: hash.digest("hex"),
+      files
     };
   };
 };
@@ -1240,9 +1249,13 @@ var FunctionSchema = z6.union([
     /** The file path of the function code. */
     file: LocalFileSchema,
     /** The name of the exported method within your code that Lambda calls to run your function.
-     * @default 'default'
+     * @default 'index.default'
      */
     handler: z6.string().optional(),
+    /** Minify the function code.
+     * @default true
+     */
+    minify: z6.boolean().optional(),
     /** Put the function inside your global VPC.
      * @default false
      */
@@ -1307,7 +1320,11 @@ var schema = z6.object({
       /** The name of the exported method within your code that Lambda calls to run your function.
        * @default 'default'
       	 */
-      handler: z6.string().default("default"),
+      handler: z6.string().default("index.default"),
+      /** Minify the function code.
+       * @default true
+       */
+      minify: z6.boolean().default(true),
       /** Put the function inside your global VPC.
        * @default false
        */
@@ -1432,7 +1449,10 @@ var toLambdaFunction = (ctx, id, fileOrProps) => {
   const props = typeof fileOrProps === "string" ? { ...config.defaults?.function, file: fileOrProps } : { ...config.defaults?.function, ...fileOrProps };
   const lambda = new Function(id, {
     name: `${config.name}-${stack.name}-${id}`,
-    code: Code.fromFile(id, props.file, rollupBundle({ handler: `index.${props.handler}` })),
+    code: Code.fromFile(id, props.file, rollupBundle({
+      handler: props.handler,
+      minify: props.minify
+    })),
     ...props,
     vpc: void 0
   });
@@ -4592,6 +4612,12 @@ var Distribution = class extends Resource {
           Quantity: this.props.originGroups?.length ?? 0,
           Items: this.props.originGroups?.map((originGroup) => originGroup.toJSON()) ?? []
         },
+        CustomErrorResponses: this.props.customErrorResponses?.map((item) => ({
+          ErrorCode: item.errorCode,
+          ...this.attr("ErrorCachingMinTTL", item.cacheMinTTL?.toSeconds()),
+          ...this.attr("ResponseCode", item.responseCode),
+          ...this.attr("ResponsePagePath", item.responsePath)
+        })) ?? [],
         DefaultCacheBehavior: {
           TargetOriginId: this.props.targetOriginId,
           ViewerProtocolPolicy: this.props.viewerProtocol ?? "redirect-to-https",
@@ -4952,6 +4978,35 @@ var ResponseHeadersPolicy = class extends Resource {
 };
 
 // src/plugins/site.ts
+var ErrorResponseSchema = z24.union([
+  z24.string(),
+  z24.object({
+    /** The path to the custom error page that you want to return to the viewer when your origin returns the HTTP status code specified.
+     * @example ```
+     * "/404.html"
+     * ```
+     *
+     * We recommend that you store custom error pages in an Amazon S3 bucket.
+     * If you store custom error pages on an HTTP server and the server starts to return 5xx errors,
+     * CloudFront can't get the files that you want to return to viewers because the origin server is unavailable.
+     */
+    path: z24.string(),
+    /** The HTTP status code that you want CloudFront to return to the viewer along with the custom error page.
+     * There are a variety of reasons that you might want CloudFront to return a status code different from the status code that your origin returned to CloudFront, for example:
+     * - Some Internet devices (some firewalls and corporate proxies, for example) intercept HTTP 4xx and 5xx and prevent the response from being returned to the viewer.
+     * If you substitute 200, the response typically won't be intercepted.
+     * - If you don't care about distinguishing among different client errors or server errors, you can specify 400 or 500 as the ResponseCode for all 4xx or 5xx errors.
+     * - You might want to return a 200 status code (OK) and static website so your customers don't know that your website is down.
+     */
+    statusCode: z24.number().int().positive().optional(),
+    /** The minimum amount of time, that you want to cache the error response.
+     * When this time period has elapsed, CloudFront queries your origin to see whether the problem that caused the error has been resolved and the requested object is now available.
+     * @example
+     * "1 day"
+     */
+    minTTL: DurationSchema.optional()
+  })
+]).optional();
 var sitePlugin = definePlugin({
   name: "site",
   schema: z24.object({
@@ -4961,12 +5016,13 @@ var sitePlugin = definePlugin({
        * {
        *   sites: {
        *     SITE_NAME: {
-       *       static: 'dist/client'
-       *       ssr: 'dist/server/index.js'
+       *       domain: 'example.com',
+       *       static: 'dist/client',
+       *       ssr: 'dist/server/index.js',
        *     }
        *   }
        * }
-       * */
+       */
       sites: z24.record(
         ResourceIdSchema,
         z24.object({
@@ -4977,6 +5033,31 @@ var sitePlugin = definePlugin({
           static: LocalDirectorySchema.optional(),
           /** Specifies the ssr file. */
           ssr: FunctionSchema.optional(),
+          /** Customize the error responses for specific HTTP status codes. */
+          errors: z24.object({
+            /** Customize a `400 Bad Request` response */
+            400: ErrorResponseSchema,
+            /** Customize a `403 Forbidden` response. */
+            403: ErrorResponseSchema,
+            /** Customize a `404 Not Found` response. */
+            404: ErrorResponseSchema,
+            /** Customize a `405 Method Not Allowed` response. */
+            405: ErrorResponseSchema,
+            /** Customize a `414 Request-URI Too Long` response. */
+            414: ErrorResponseSchema,
+            /** Customize a `416 Range Not Satisfiable` response. */
+            416: ErrorResponseSchema,
+            /** Customize a `500 Internal Server Error` response. */
+            500: ErrorResponseSchema,
+            /** Customize a `501 Not Implemented` response. */
+            501: ErrorResponseSchema,
+            /** Customize a `502 Bad Gateway` response. */
+            502: ErrorResponseSchema,
+            /** Customize a `503 Service Unavailable` response. */
+            503: ErrorResponseSchema,
+            /** Customize a `504 Gateway Timeout` response. */
+            504: ErrorResponseSchema
+          }).optional(),
           /** Define the cors headers. */
           cors: z24.object({
             override: z24.boolean().default(false),
@@ -5148,7 +5229,22 @@ var sitePlugin = definePlugin({
         targetOriginId: props.ssr && props.static ? "group" : props.ssr ? "lambda" : "bucket",
         originRequestPolicyId: originRequest.id,
         cachePolicyId: cache.id,
-        responseHeadersPolicyId: responseHeaders.id
+        responseHeadersPolicyId: responseHeaders.id,
+        customErrorResponses: Object.entries(props.errors ?? {}).map(([errorCode, item]) => {
+          if (typeof item === "string") {
+            return {
+              errorCode,
+              responsePath: item,
+              responseCode: Number(errorCode)
+            };
+          }
+          return {
+            errorCode,
+            cacheMinTTL: item.minTTL,
+            responsePath: item.path,
+            responseCode: item.statusCode ?? Number(errorCode)
+          };
+        })
       }).dependsOn(originRequest, responseHeaders, cache, ...deps);
       if (props.static) {
         const bucketPolicy = new BucketPolicy(`site-${id}`, {

package/dist/features/invalidate-cache.js

@@ -0,0 +1,78 @@
+import { CloudFrontClient, CreateInvalidationCommand, waitUntilInvalidationCompleted } from '@aws-sdk/client-cloudfront';
+
+const send = async (event, id, status, data, reason = '')=>{
+    const body = JSON.stringify({
+        Status: status,
+        Reason: reason,
+        PhysicalResourceId: id,
+        StackId: event.StackId,
+        RequestId: event.RequestId,
+        LogicalResourceId: event.LogicalResourceId,
+        NoEcho: false,
+        Data: data
+    });
+    // @ts-ignore
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength
+        }
+    });
+};
+
+const client = new CloudFrontClient({});
+const handler = async (event)=>{
+    const type = event.RequestType;
+    const { distributionId, paths, waitForInvalidation } = event.ResourceProperties;
+    console.log('Type', type);
+    console.log('DistributionId', distributionId);
+    console.log('Paths', paths);
+    console.log('WaitForInvalidation', waitForInvalidation);
+    try {
+        if (type === 'Update') {
+            const id = await invalidateCache(distributionId, paths);
+            if (waitForInvalidation) {
+                await wait(distributionId, id);
+            }
+        }
+        await send(event, distributionId, 'SUCCESS');
+    } catch (error) {
+        if (error instanceof Error) {
+            await send(event, distributionId, 'FAILED', {}, error.message);
+        } else {
+            await send(event, distributionId, 'FAILED', {}, 'Unknown error');
+        }
+        console.error(error);
+    }
+};
+const invalidateCache = async (distributionId, paths)=>{
+    const result = await client.send(new CreateInvalidationCommand({
+        DistributionId: distributionId,
+        InvalidationBatch: {
+            CallerReference: Date.now().toString(),
+            Paths: {
+                Quantity: paths.length,
+                Items: paths
+            }
+        }
+    }));
+    return result.Invalidation.Id;
+};
+const wait = async (distributionId, id)=>{
+    try {
+        await waitUntilInvalidationCompleted({
+            client,
+            maxWaitTime: 600
+        }, {
+            DistributionId: distributionId,
+            Id: id
+        });
+    } catch (error) {
+        console.error(error);
+    }
+};
+
+export { handler };