@jcoreio/toolchain-aws-lambda 4.3.0

package/bin/pack-lambda

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+exec $(node "$basedir/resolveBin.cjs" pack-lambda) "$@"

package/bin/resolveBin.cjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+process.stdout.write(
+  require('resolve-bin').sync(
+    process.argv[2],
+    process.argv[3] ? { executable: process.argv[3] } : {}
+  )
+)

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@jcoreio/toolchain-aws-lambda",
+  "version": "4.3.0",
+  "description": "AWS Lambda function build toolchain",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jcoreio/toolchains.git",
+    "directory": "packages/aws-lambda"
+  },
+  "author": "Andy Edwards",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jcoreio/toolchains/issues"
+  },
+  "homepage": "https://github.com/jcoreio/toolchains/tree/main/packages/aws-lambda",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.575.0",
+    "@aws-sdk/client-sts": "^3.575.0",
+    "@jcoreio/cloudformation-tools": "^5.1.1",
+    "@jcoreio/pack-lambda": "^2.0.0",
+    "@semantic-release/exec": "^6.0.3",
+    "dedent-js": "^1.0.1",
+    "dotenv": "^16.4.5",
+    "resolve-bin": "^1.0.0",
+    "zod": "^3.21.4",
+    "@jcoreio/toolchain": "4.3.0"
+  },
+  "toolchainManaged": {
+    "devDependencies": {
+      "@types/aws-lambda": "^8.10.137"
+    }
+  }
+}

package/plugins/getConfigFiles.cjs

@@ -0,0 +1,56 @@
+const dedent = require('dedent-js')
+const { toolchainPackages } = require('../util/findUps.cjs')
+
+module.exports = [
+  async function getConfigFiles() {
+    const isTS = toolchainPackages.includes('@jcoreio/toolchain-typescript')
+    const files = {
+      [`src/index.${isTS ? 'ts' : 'js'}`]: dedent`
+        // eslint-disable-next-line @jcoreio/implicit-dependencies/no-implicit
+        import type { Handler } from 'aws-lambda'
+
+        export const handler: Handler = async (event, context) => {
+          
+        }
+      `,
+      [`scripts/cloudFormationTemplate.${isTS ? 'ts' : 'js'}`]: dedent`
+        // export const StackName = 'StackName'
+
+        export const Template = {
+          AWSTemplateFormatVersion: '2010-09-09',
+          // Description: 'Template Descrption',
+          Transform: 'AWS::Serverless-2016-10-31',
+          Parameters: {
+
+          },
+          Resources: {
+            LambdaFunction: {
+              Type: 'AWS::Serverless::Function',
+              Properties: {
+                MemorySize: 128,
+                Timeout: 60,
+                // CodeUri: {
+                //   Bucket: 'BucketName',
+                // },
+              },
+            },
+          },
+          Outputs: {
+            LambdaFunction: { Value: { Ref: 'LambdaFunction' } },
+          },
+        }
+        
+        export const Parameters = {
+
+        }
+        
+        export const Capabilities = ['CAPABILITY_IAM']
+
+        export const Tags = {
+
+        }
+      `,
+    }
+    return files
+  },
+]

package/plugins/scripts.cjs

@@ -0,0 +1,19 @@
+const execa = require('@jcoreio/toolchain/util/execa.cjs')
+const fs = require('@jcoreio/toolchain/util/projectFs.cjs')
+const deploy = require('../scripts/deploy.cjs')
+
+module.exports = [
+  {
+    predeploy: {
+      description: 'prepare to deploy lambda function',
+      run: async (args = []) => {
+        await execa('tc', ['build'])
+        await fs.ensureSymlink('node_modules', 'dist/node_modules', 'dir')
+      },
+    },
+    deploy: {
+      description: 'deploy lambda function to AWS',
+      run: deploy,
+    },
+  },
+]

package/plugins/semanticReleasePlugins.cjs

@@ -0,0 +1,8 @@
+module.exports = [
+  () => [
+    require.resolve('@semantic-release/exec'),
+    {
+      publishCmd: 'npm version ${nextRelease.version} && tc deploy',
+    },
+  ],
+]

package/scripts/deploy.cjs

@@ -0,0 +1,191 @@
+const {
+  projectDir,
+  toolchainPackages,
+} = require('@jcoreio/toolchain/util/findUps.cjs')
+const fs = require('@jcoreio/toolchain/util/projectFs.cjs')
+const { uploadToS3 } = require('@jcoreio/pack-lambda')
+const path = require('path')
+const { inspect } = require('util')
+const { S3Client, CreateBucketCommand } = require('@aws-sdk/client-s3')
+const { STSClient, GetCallerIdentityCommand } = require('@aws-sdk/client-sts')
+const { deployCloudFormationStack } = require('@jcoreio/cloudformation-tools')
+const z = require('zod').default
+
+const TemplateModuleSchema = z.strictObject({
+  StackName: z.string().optional(),
+  Parameters: z.record(z.any()).optional(),
+  Template: z
+    .object({
+      Parameters: z
+        .record(
+          z
+            .object({
+              Type: z.string(),
+              Description: z.string().optional(),
+              Default: z.any().optional(),
+            })
+            .passthrough()
+        )
+        .optional(),
+      Resources: z.record(z.object({ Type: z.string() }).passthrough()),
+    })
+    .passthrough(),
+  Capabilities: z
+    .array(
+      z.enum([
+        'CAPABILITY_IAM',
+        'CAPABILITY_NAMED_IAM',
+        'CAPABILITY_AUTO_EXPAND',
+      ])
+    )
+    .optional(),
+  Tags: z
+    .union([
+      z.record(z.string()),
+      z.array(z.object({ Tag: z.string(), Value: z.string() })),
+    ])
+    .optional(0),
+})
+
+module.exports = async function deploy() {
+  const packageJsonFile = path.join(projectDir, 'dist', 'package.json')
+  const packageJson = await fs.readJson(packageJsonFile)
+  require('dotenv').config()
+
+  if (toolchainPackages.includes('@jcoreio/toolchain-esnext')) {
+    // eslint-disable-next-line @jcoreio/implicit-dependencies/no-implicit
+    require(require.resolve(
+      '@jcoreio/toolchain-esnext/util/babelRegister.cjs',
+      { paths: [projectDir] }
+    ))
+  }
+  const templatePath = path.join(
+    projectDir,
+    'scripts',
+    'cloudFormationTemplate'
+  )
+  const templateModule = TemplateModuleSchema.parse(require(templatePath))
+  const { Template, Parameters, Capabilities, Tags } = templateModule
+  let { StackName } = templateModule
+
+  if (!Template.Description) Template.Description = packageJson.Description
+
+  const [lambda, ...excessLambdas] = Object.entries(
+    Template.Resources || {}
+  ).filter(
+    ([key, value]) =>
+      value.Type === 'AWS::Serverless::Function' ||
+      value.Type === 'AWS::Lambda::Function'
+  )
+  if (!lambda) {
+    throw new Error(
+      `Missing lambda function in Template export in ${path.relative(
+        process.cwd(),
+        templatePath
+      )}`
+    )
+  }
+  if (excessLambdas.length) {
+    throw new Error(
+      `${path.relative(
+        process.cwd(),
+        templatePath
+      )} contains more than one lambda function, this is not supported`
+    )
+  }
+
+  const [lambdaResourceName, lambdaResource] = lambda
+
+  const { Properties } = lambdaResource
+  if (!Properties) {
+    throw new Error(`Missing Properties on ${lambdaResourceName} resource`)
+  }
+
+  if (!Properties.Handler) {
+    if (!packageJson.main) {
+      throw new Error(
+        `missing "Handler" in lambda function properties or "main" in ${path.relative(
+          process.cwd(),
+          packageJsonFile
+        )}`
+      )
+    }
+    Properties.Handler = packageJson.main.replace(/\.[^.]+$/, '.handler')
+  }
+
+  if (!Properties.CodeUri) Properties.CodeUri = {}
+  const { CodeUri } = Properties
+
+  if (!CodeUri.Bucket) {
+    const sts = new STSClient()
+    const { Account } = await sts.send(new GetCallerIdentityCommand({}))
+    // eslint-disable-next-line no-console
+    console.error(`Defaulting Lambda CodeUri.Bucket to AWS Account: ${Account}`)
+    CodeUri.Bucket = Account
+  }
+
+  let Bucket = CodeUri.Bucket
+  if (CodeUri.Bucket instanceof Object) {
+    if (CodeUri.Bucket.Ref) {
+      Bucket =
+        Parameters[CodeUri.Bucket.Ref] ||
+        (Template.Parameters[CodeUri.Bucket.Ref] || {}).Default
+    }
+    throw new Error(
+      `Lambda CodeUri.Bucket format not supported: ${inspect(Bucket)}`
+    )
+  }
+  let Key = CodeUri.Key
+
+  const s3 = new S3Client()
+  try {
+    await s3.send(new CreateBucketCommand({ Bucket }))
+    // eslint-disable-next-line no-console
+    console.error(`Created S3 Bucket: ${Bucket}`)
+  } catch (error) {
+    if (!error.stack.includes('BucketAlreadyOwnedByYou')) {
+      // eslint-disable-next-line no-console
+      console.error(error)
+    }
+  }
+
+  ;({ Key } = await uploadToS3({
+    packageDir: path.resolve(projectDir, 'dist'),
+    Bucket,
+    Key,
+  }))
+  CodeUri.Key = Key
+
+  if (!Properties.Runtime) {
+    Properties.Runtime = `nodejs20.x`
+    // eslint-disable-next-line no-console
+    console.error(`Defaulting Lambda Runtime to ${Properties.Runtime}`)
+  }
+
+  if (!Properties.FunctionName) {
+    Properties.FunctionName = packageJson.name
+      .replace(/[^-a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '')
+    // eslint-disable-next-line no-console
+    console.error(
+      `Defaulting Lambda FunctionName to ${Properties.FunctionName}`
+    )
+  }
+
+  if (!StackName) {
+    StackName = Properties.FunctionName.replace(/[^-a-z0-9]+/g, '-').replace(
+      /^-+|-+$/g,
+      ''
+    )
+    // eslint-disable-next-line no-console
+    console.error(`Defaulting StackName to ${StackName}`)
+  }
+
+  await deployCloudFormationStack({
+    StackName,
+    Template,
+    Parameters,
+    Capabilities,
+    Tags,
+  })
+}