@awsless/awsless 0.0.85 → 0.0.86

package/dist/features/cognito-client-secret/HASH

@@ -0,0 +1 @@
+64ab50c75f36adcc289b9470606a9a989516e8b1

package/dist/features/cognito-client-secret/index.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var clientCognitoIdentityProvider = require('@aws-sdk/client-cognito-identity-provider');
+
+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
+    });
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        // @ts-ignore
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength.toString()
+        }
+    });
+};
+
+const client = new clientCognitoIdentityProvider.CognitoIdentityProviderClient({});
+const handler = async (event)=>{
+    const type = event.RequestType;
+    const userPoolId = event.ResourceProperties.userPoolId;
+    const clientId = event.ResourceProperties.clientId;
+    console.log('Type:', type);
+    console.log('UserPoolId:', userPoolId);
+    console.log('ClientId:', clientId);
+    try {
+        if (type === 'Create' || type === 'Update') {
+            const input = {
+                UserPoolId: userPoolId,
+                ClientId: clientId
+            };
+            const command = new clientCognitoIdentityProvider.DescribeUserPoolClientCommand(input);
+            const response = await client.send(command);
+            const secret = response.UserPoolClient?.ClientSecret;
+            await send(event, clientId, 'SUCCESS', {
+                secret
+            });
+        } else {
+            await send(event, clientId, 'SUCCESS');
+        }
+    } catch (error) {
+        if (error instanceof Error) {
+            await send(event, clientId, 'FAILED', {}, error.message);
+        } else {
+            await send(event, clientId, 'FAILED', {}, 'Unknown error');
+        }
+        console.error(error);
+    }
+};
+
+exports.handler = handler;

package/dist/features/cognito-client-secret/index.mjs

@@ -0,0 +1,59 @@
+import { CognitoIdentityProviderClient, DescribeUserPoolClientCommand } from '@aws-sdk/client-cognito-identity-provider';
+
+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
+    });
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        // @ts-ignore
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength.toString()
+        }
+    });
+};
+
+const client = new CognitoIdentityProviderClient({});
+const handler = async (event)=>{
+    const type = event.RequestType;
+    const userPoolId = event.ResourceProperties.userPoolId;
+    const clientId = event.ResourceProperties.clientId;
+    console.log('Type:', type);
+    console.log('UserPoolId:', userPoolId);
+    console.log('ClientId:', clientId);
+    try {
+        if (type === 'Create' || type === 'Update') {
+            const input = {
+                UserPoolId: userPoolId,
+                ClientId: clientId
+            };
+            const command = new DescribeUserPoolClientCommand(input);
+            const response = await client.send(command);
+            const secret = response.UserPoolClient?.ClientSecret;
+            await send(event, clientId, 'SUCCESS', {
+                secret
+            });
+        } else {
+            await send(event, clientId, 'SUCCESS');
+        }
+    } catch (error) {
+        if (error instanceof Error) {
+            await send(event, clientId, 'FAILED', {}, error.message);
+        } else {
+            await send(event, clientId, 'FAILED', {}, 'Unknown error');
+        }
+        console.error(error);
+    }
+};
+
+export { handler };

package/dist/features/delete-bucket/HASH

@@ -0,0 +1 @@
+9ef61dd651048b674d78dd0938766f5abfb1574a

package/dist/features/delete-bucket/index.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var clientS3 = require('@aws-sdk/client-s3');
+
+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
+    });
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        // @ts-ignore
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength.toString()
+        }
+    });
+};
+
+const client = new clientS3.S3Client({});
+const handler = async (event)=>{
+    const type = event.RequestType;
+    const bucketName = event.ResourceProperties.bucketName;
+    console.log('Type:', type);
+    console.log('BucketName:', bucketName);
+    try {
+        if (type === 'Delete') {
+            console.log('Deleting bucket objects...');
+            await emptyBucket(bucketName);
+            console.log('Done');
+        }
+        await send(event, bucketName, 'SUCCESS');
+    } catch (error) {
+        if (error instanceof Error) {
+            await send(event, bucketName, 'FAILED', {}, error.message);
+        } else {
+            await send(event, bucketName, 'FAILED', {}, 'Unknown error');
+        }
+        console.error(error);
+    }
+};
+const emptyBucket = async (bucket)=>{
+    while(true){
+        const result = await client.send(new clientS3.ListObjectsV2Command({
+            Bucket: bucket,
+            MaxKeys: 1000
+        }));
+        if (!result.Contents || result.Contents.length === 0) {
+            break;
+        }
+        await client.send(new clientS3.DeleteObjectsCommand({
+            Bucket: bucket,
+            Delete: {
+                Objects: result.Contents.map((object)=>({
+                        Key: object.Key
+                    }))
+            }
+        }));
+    }
+    while(true){
+        const result = await client.send(new clientS3.ListObjectVersionsCommand({
+            Bucket: bucket,
+            MaxKeys: 1000
+        }));
+        if (!result.Versions || result.Versions.length === 0) {
+            break;
+        }
+        await client.send(new clientS3.DeleteObjectsCommand({
+            Bucket: bucket,
+            Delete: {
+                Objects: result.Versions.map((object)=>({
+                        Key: object.Key,
+                        VersionId: object.VersionId
+                    }))
+            }
+        }));
+    }
+};
+
+exports.handler = handler;

package/dist/features/{delete-bucket.js → delete-bucket/index.mjs}

@@ -11,14 +11,14 @@ const send = async (event, id, status, data, reason = '')=>{
         NoEcho: false,
         Data: data
     });
-    // @ts-ignore
     await fetch(event.ResponseURL, {
         method: 'PUT',
+        // @ts-ignore
         port: 443,
         body,
         headers: {
             'content-type': '',
-            'content-length': Buffer.from(body).byteLength
+            'content-length': Buffer.from(body).byteLength.toString()
         }
     });
 };

package/dist/features/delete-hosted-zone/HASH

@@ -0,0 +1 @@
+8752aafdfc559d1e4b7002f66a35e58c71ec17f4

package/dist/features/delete-hosted-zone/index.js

@@ -0,0 +1,130 @@
+'use strict';
+
+var clientRoute53 = require('@aws-sdk/client-route-53');
+
+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
+    });
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        // @ts-ignore
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength.toString()
+        }
+    });
+};
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var chunk$1 = {exports: {}};
+
+(function (module, exports) {
+
+	(function () {
+	  function chunk(collection, size) {
+	    var result = [];
+
+	    // default size to two item
+	    size = parseInt(size) || 2;
+
+	    // add each chunk to the result
+	    for (var x = 0; x < Math.ceil(collection.length / size); x++) {
+	      var start = x * size;
+	      var end = start + size;
+
+	      result.push(collection.slice(start, end));
+	    }
+
+	    return result;
+	  }
+
+	  // export in node or browser
+	  {
+	    if (module.exports) {
+	      exports = module.exports = chunk;
+	    }
+	    exports.chunk = chunk;
+	  }
+	}.call(commonjsGlobal)); 
+} (chunk$1, chunk$1.exports));
+
+var chunkExports = chunk$1.exports;
+var chunk = /*@__PURE__*/getDefaultExportFromCjs(chunkExports);
+
+const client = new clientRoute53.Route53Client({});
+const handler = async (event)=>{
+    const type = event.RequestType;
+    const hostedZoneId = event.ResourceProperties.hostedZoneId;
+    console.log('Type:', type);
+    console.log('HostedZoneId:', hostedZoneId);
+    try {
+        if (type === 'Delete') {
+            const records = await listHostedZoneRecords(hostedZoneId);
+            console.log('Records:', records);
+            await deleteHostedZoneRecords(hostedZoneId, records);
+        }
+        await send(event, hostedZoneId, 'SUCCESS');
+    } catch (error) {
+        if (error instanceof Error) {
+            await send(event, hostedZoneId, 'FAILED', {}, error.message);
+        } else {
+            await send(event, hostedZoneId, 'FAILED', {}, 'Unknown error');
+        }
+        console.error(error);
+    }
+};
+const deleteHostedZoneRecords = async (hostedZoneId, records)=>{
+    records = records.filter((record)=>![
+            'SOA',
+            'NS'
+        ].includes(record.Type));
+    if (records.length === 0) {
+        return;
+    }
+    await Promise.all(chunk(records, 100).map(async (records)=>{
+        await client.send(new clientRoute53.ChangeResourceRecordSetsCommand({
+            HostedZoneId: hostedZoneId,
+            ChangeBatch: {
+                Changes: records.map((record)=>({
+                        Action: 'DELETE',
+                        ResourceRecordSet: record
+                    }))
+            }
+        }));
+    }));
+};
+const listHostedZoneRecords = async (hostedZoneId)=>{
+    const records = [];
+    let token;
+    while(true){
+        const result = await client.send(new clientRoute53.ListResourceRecordSetsCommand({
+            HostedZoneId: hostedZoneId,
+            StartRecordName: token
+        }));
+        if (result.ResourceRecordSets && result.ResourceRecordSets.length) {
+            records.push(...result.ResourceRecordSets);
+        }
+        if (result.NextRecordName) {
+            token = result.NextRecordName;
+        } else {
+            return records;
+        }
+    }
+};
+
+exports.handler = handler;

package/dist/features/{delete-hosted-zone.js → delete-hosted-zone/index.mjs}

@@ -11,14 +11,14 @@ const send = async (event, id, status, data, reason = '')=>{
         NoEcho: false,
         Data: data
     });
-    // @ts-ignore
     await fetch(event.ResponseURL, {
         method: 'PUT',
+        // @ts-ignore
         port: 443,
         body,
         headers: {
             'content-type': '',
-            'content-length': Buffer.from(body).byteLength
+            'content-length': Buffer.from(body).byteLength.toString()
         }
     });
 };

package/dist/features/global-exports/HASH

@@ -0,0 +1 @@
+24e4c709abee1432751de78eedbf776fa574e8e4

package/dist/features/global-exports/index.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var clientCloudformation = require('@aws-sdk/client-cloudformation');
+
+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
+    });
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        // @ts-ignore
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength.toString()
+        }
+    });
+};
+
+const handler = async (event)=>{
+    const region = event.ResourceProperties.region;
+    try {
+        const data = await listExports(region);
+        await send(event, region, 'SUCCESS', data);
+    } catch (error) {
+        if (error instanceof Error) {
+            await send(event, region, 'FAILED', {}, error.message);
+        } else {
+            await send(event, region, 'FAILED', {}, 'Unknown error');
+        }
+        console.error(error);
+    }
+};
+const listExports = async (region)=>{
+    const client = new clientCloudformation.CloudFormationClient({
+        region
+    });
+    const data = {};
+    let token;
+    while(true){
+        const result = await client.send(new clientCloudformation.ListExportsCommand({
+            NextToken: token
+        }));
+        result.Exports?.forEach((item)=>{
+            data[item.Name] = item.Value;
+        });
+        if (result.NextToken) {
+            token = result.NextToken;
+        } else {
+            return data;
+        }
+    }
+};
+
+exports.handler = handler;

package/dist/features/{global-exports.js → global-exports/index.mjs}

@@ -11,14 +11,14 @@ const send = async (event, id, status, data, reason = '')=>{
         NoEcho: false,
         Data: data
     });
-    // @ts-ignore
     await fetch(event.ResponseURL, {
         method: 'PUT',
+        // @ts-ignore
         port: 443,
         body,
         headers: {
             'content-type': '',
-            'content-length': Buffer.from(body).byteLength
+            'content-length': Buffer.from(body).byteLength.toString()
         }
     });
 };

package/dist/features/invalidate-cache/HASH

@@ -0,0 +1 @@
+57596b321a7e724d843a87434ff5bb3cc0b46931

package/dist/features/invalidate-cache/index.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var clientCloudfront = require('@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
+    });
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        // @ts-ignore
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength.toString()
+        }
+    });
+};
+
+const client = new clientCloudfront.CloudFrontClient({});
+const handler = async (event)=>{
+    const type = event.RequestType;
+    const { distributionId, paths } = event.ResourceProperties;
+    console.log('Type', type);
+    console.log('DistributionId', distributionId);
+    console.log('Paths', paths);
+    try {
+        if (type === 'Update') {
+            await invalidateCache(distributionId, paths);
+        }
+        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 clientCloudfront.CreateInvalidationCommand({
+        DistributionId: distributionId,
+        InvalidationBatch: {
+            CallerReference: Date.now().toString(),
+            Paths: {
+                Quantity: paths.length,
+                Items: paths
+            }
+        }
+    }));
+    return result.Invalidation.Id;
+};
+
+exports.handler = handler;

package/dist/features/{invalidate-cache.js → invalidate-cache/index.mjs}

@@ -11,14 +11,14 @@ const send = async (event, id, status, data, reason = '')=>{
         NoEcho: false,
         Data: data
     });
-    // @ts-ignore
     await fetch(event.ResponseURL, {
         method: 'PUT',
+        // @ts-ignore
         port: 443,
         body,
         headers: {
             'content-type': '',
-            'content-length': Buffer.from(body).byteLength
+            'content-length': Buffer.from(body).byteLength.toString()
         }
     });
 };

package/dist/features/upload-bucket-asset/HASH

@@ -0,0 +1 @@
+022a1f0af1891993ff757275d5ed82fc70eabb74