@awsless/awsless 0.0.44 → 0.0.45

package/dist/features/delete-bucket.js

@@ -0,0 +1,86 @@
+import { S3Client, ListObjectsV2Command, DeleteObjectsCommand, ListObjectVersionsCommand } from '@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
+    });
+    // @ts-ignore
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength
+        }
+    });
+};
+
+const client = new 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 ListObjectsV2Command({
+            Bucket: bucket,
+            MaxKeys: 1000
+        }));
+        if (!result.Contents || result.Contents.length === 0) {
+            break;
+        }
+        await client.send(new DeleteObjectsCommand({
+            Bucket: bucket,
+            Delete: {
+                Objects: result.Contents.map((object)=>({
+                        Key: object.Key
+                    }))
+            }
+        }));
+    }
+    while(true){
+        const result = await client.send(new ListObjectVersionsCommand({
+            Bucket: bucket,
+            MaxKeys: 1000
+        }));
+        if (!result.Versions || result.Versions.length === 0) {
+            break;
+        }
+        await client.send(new DeleteObjectsCommand({
+            Bucket: bucket,
+            Delete: {
+                Objects: result.Versions.map((object)=>({
+                        Key: object.Key,
+                        VersionId: object.VersionId
+                    }))
+            }
+        }));
+    }
+};
+
+export { handler };

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

@@ -0,0 +1,127 @@
+import { Route53Client, ChangeResourceRecordSetsCommand, ListResourceRecordSetsCommand } from '@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
+    });
+    // @ts-ignore
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength
+        }
+    });
+};
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var chunkExports = {};
+var chunk$1 = {
+  get exports(){ return chunkExports; },
+  set exports(v){ chunkExports = v; },
+};
+
+(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, chunkExports));
+
+var chunk = chunkExports;
+
+const client = new 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 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 ListResourceRecordSetsCommand({
+            HostedZoneId: hostedZoneId,
+            StartRecordName: token
+        }));
+        if (result.ResourceRecordSets && result.ResourceRecordSets.length) {
+            records.push(...result.ResourceRecordSets);
+        }
+        if (result.NextRecordName) {
+            token = result.NextRecordName;
+        } else {
+            return records;
+        }
+    }
+};
+
+export { handler };

package/dist/features/global-exports.js

@@ -0,0 +1,61 @@
+import { CloudFormationClient, ListExportsCommand } from '@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
+    });
+    // @ts-ignore
+    await fetch(event.ResponseURL, {
+        method: 'PUT',
+        port: 443,
+        body,
+        headers: {
+            'content-type': '',
+            'content-length': Buffer.from(body).byteLength
+        }
+    });
+};
+
+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 CloudFormationClient({
+        region
+    });
+    const data = {};
+    let token;
+    while(true){
+        const result = await client.send(new ListExportsCommand({
+            NextToken: token
+        }));
+        result.Exports?.forEach((item)=>{
+            data[item.Name] = item.Value;
+        });
+        if (result.NextToken) {
+            token = result.NextToken;
+        } else {
+            return data;
+        }
+    }
+};
+
+export { handler };