@bifravst/aws-cdk-lambda-helpers 1.0.0

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Nordic Semiconductor ASA | nordicsemi.no
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,14 @@
+# AWS CDK Lambda Helpers [![npm version](https://img.shields.io/npm/v/@bifravst/aws-cdk-lambda-helpers.svg)](https://www.npmjs.com/package/@bifravst/aws-cdk-lambda-helpers)
+
+[![GitHub Actions](https://github.com/bifravst/aws-cdk-lambda-helpers/workflows/Test%20and%20Release/badge.svg)](https://github.com/bifravst/aws-cdk-lambda-helpers/actions)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+[![Renovate](https://img.shields.io/badge/renovate-enabled-brightgreen.svg)](https://renovatebot.com)
+[![@commitlint/config-conventional](https://img.shields.io/badge/%40commitlint-config--conventional-brightgreen)](https://github.com/conventional-changelog/commitlint/tree/master/@commitlint/config-conventional)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier/)
+[![ESLint: TypeScript](https://img.shields.io/badge/ESLint-TypeScript-blue.svg)](https://github.com/typescript-eslint/typescript-eslint)
+
+Helper functions which simplify working with TypeScript lambdas for AWS CDK.
+
+## Installation
+
+    npm i --save --save-exact @bifravst/aws-cdk-lambda-helpers

package/dist/checkSumOfFiles.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/checkSumOfFiles.spec.js

@@ -0,0 +1,16 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { checkSumOfFiles } from './checksumOfFiles.js';
+void describe('checkSumOfFiles()', () => {
+    void it('should calculate a checksum of files', async () => assert.equal(await checkSumOfFiles([
+        // sha1sum cdk/helpers/lambdas/test-data/1.txt
+        // 6ae3f2029d36e029175cc225c2c4cda51a5ac602  cdk/helpers/lambdas/test-data/1.txt
+        path.join(process.cwd(), 'src', 'test-data', '1.txt'),
+        // sha1sum cdk/helpers/lambdas/test-data/2.txt
+        // 6a9c3333d7a3f9ee9fa1ef70224766fafb208fe4  cdk/helpers/lambdas/test-data/2.txt
+        path.join(process.cwd(), 'src', 'test-data', '2.txt'),
+    ]), 
+    // echo -n 6ae3f2029d36e029175cc225c2c4cda51a5ac6026a9c3333d7a3f9ee9fa1ef70224766fafb208fe4 | sha1sum
+    'baa003a894945a0d2519b1f4340caa97c462058f'));
+});

package/dist/checksumOfFiles.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Computes the combined checksum of the given files
+ */
+export declare const checkSumOfFiles: (files: string[]) => Promise<string>;
+export declare const checkSumOfStrings: (strings: string[]) => string;

package/dist/checksumOfFiles.js

@@ -0,0 +1,42 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+/**
+ * Computes the combined checksum of the given files
+ */
+export const checkSumOfFiles = async (files) => {
+    const fileChecksums = await checkSum(files);
+    const checksum = checkSumOfStrings([...Object.entries(fileChecksums)].map(([, hash]) => hash));
+    return checksum;
+};
+export const checkSumOfStrings = (strings) => {
+    const hash = crypto.createHash('sha1');
+    hash.update(strings.join(''));
+    return hash.digest('hex');
+};
+const hashCache = {};
+const hashFile = async (file) => {
+    if (hashCache[file] === undefined) {
+        hashCache[file] = await new Promise((resolve) => {
+            const hash = crypto.createHash('sha1');
+            hash.setEncoding('hex');
+            const fileStream = fs.createReadStream(file);
+            fileStream.pipe(hash, { end: false });
+            fileStream.on('end', () => {
+                hash.end();
+                const h = hash.read().toString();
+                resolve(h);
+            });
+        });
+    }
+    return hashCache[file];
+};
+/**
+ * Computes the checksum for the given files
+ */
+const checkSum = async (files) => {
+    const hashes = {};
+    await files.reduce(async (p, file) => p.then(async () => {
+        hashes[file] = await hashFile(file);
+    }), Promise.resolve());
+    return hashes;
+};

package/dist/commonParent.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns the common ancestor directory from a list of files
+ */
+export declare const commonParent: (files: string[]) => string;

package/dist/commonParent.js

@@ -0,0 +1,14 @@
+import { parse, sep } from 'node:path';
+/**
+ * Returns the common ancestor directory from a list of files
+ */
+export const commonParent = (files) => {
+    if (files.length === 1)
+        return parse(files[0] ?? '').dir + sep;
+    let index = 0;
+    let prefix = '/';
+    while (files.filter((f) => f.startsWith(prefix)).length === files.length) {
+        prefix = files[0]?.slice(0, index++) ?? '';
+    }
+    return prefix.slice(0, prefix.lastIndexOf('/') + 1);
+};

package/dist/commonParent.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commonParent.spec.js

@@ -0,0 +1,20 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { commonParent } from './commonParent.js';
+void describe('commonParent()', () => {
+    void it('should return the common parent directory', () => assert.equal(commonParent([
+        '/some/dir/lambda/onMessage.ts',
+        '/some/dir/lambda/notifyClients.ts',
+        '/some/dir/lambda/wirepasPublish.ts',
+        '/some/dir/wirepas-5g-mesh-gateway/protobuf/ts/data_message.ts',
+    ]), '/some/dir/'));
+    void it('should return the entire parent tree for a single file', () => assert.equal(commonParent(['/some/dir/lambda/onMessage.ts']), '/some/dir/lambda/'));
+    void it('should return "/" if files have no common directory', () => assert.equal(commonParent([
+        '/some/dir/lambda/onMessage.ts',
+        '/other/dir/lambda/onMessage.ts',
+    ]), '/'));
+    void it('should return the common ancestor only up until the directory level', () => assert.equal(commonParent([
+        '/some/dir/lambdas/cors.ts',
+        '/some/dir/lambdas/corsHeaders.ts',
+    ]), '/some/dir/lambdas/'));
+});

package/dist/findDependencies.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Resolve project-level dependencies for the given file using TypeScript compiler API
+ */
+export declare const findDependencies: (sourceFile: string, imports?: string[], visited?: string[]) => string[];

package/dist/findDependencies.js

@@ -0,0 +1,42 @@
+import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import ts, {} from 'typescript';
+/**
+ * Resolve project-level dependencies for the given file using TypeScript compiler API
+ */
+export const findDependencies = (sourceFile, imports = [], visited = []) => {
+    if (visited.includes(sourceFile))
+        return imports;
+    const fileNode = ts.createSourceFile(sourceFile, readFileSync(sourceFile, 'utf-8').toString(), ts.ScriptTarget.ES2022, 
+    /*setParentNodes */ true);
+    const parseChild = (node) => {
+        if (node.kind !== ts.SyntaxKind.ImportDeclaration)
+            return;
+        const moduleSpecifier = node.moduleSpecifier.text;
+        const file = moduleSpecifier.startsWith('.')
+            ? path
+                .resolve(path.parse(sourceFile).dir, moduleSpecifier)
+                // In ECMA Script modules, all imports from local files must have an extension.
+                // See https://nodejs.org/api/esm.html#mandatory-file-extensions
+                // So we need to replace the `.js` in the import specification to find the TypeScript source for the file.
+                // Example: import { Network, notifyClients } from './notifyClients.js'
+                // The source file for that is actually in './notifyClients.ts'
+                .replace(/\.js$/, '.ts')
+            : moduleSpecifier;
+        try {
+            const s = statSync(file);
+            if (!s.isDirectory())
+                imports.push(file);
+        }
+        catch {
+            // Module or file not found
+            visited.push(file);
+        }
+    };
+    ts.forEachChild(fileNode, parseChild);
+    visited.push(sourceFile);
+    for (const file of imports) {
+        findDependencies(file, imports, visited);
+    }
+    return imports;
+};

package/dist/packLambda.d.ts

@@ -0,0 +1,18 @@
+export type PackedLambda = {
+    id: string;
+    zipFile: string;
+    handler: string;
+    hash: string;
+};
+/**
+ * In the bundle we only include code that's not in the layer.
+ */
+export declare const packLambda: ({ sourceFile, zipFile, debug, progress, }: {
+    sourceFile: string;
+    zipFile: string;
+    debug?: (label: string, info: string) => void;
+    progress?: (label: string, info: string) => void;
+}) => Promise<{
+    handler: string;
+    hash: string;
+}>;

package/dist/packLambda.js

@@ -0,0 +1,56 @@
+import swc from '@swc/core';
+import { createWriteStream } from 'node:fs';
+import { parse } from 'path';
+import yazl from 'yazl';
+import { checkSumOfFiles } from './checksumOfFiles.js';
+import { commonParent } from './commonParent.js';
+import { findDependencies } from './findDependencies.js';
+import { fileURLToPath } from 'node:url';
+const removeCommonAncestor = (parentDir) => (file) => {
+    const p = parse(file);
+    const jsFileName = [
+        p.dir.replace(parentDir.slice(0, parentDir.length - 1), ''),
+        `${p.name}.js`,
+    ]
+        .join('/')
+        // Replace leading slash
+        .replace(/^\//, '');
+    return jsFileName;
+};
+/**
+ * In the bundle we only include code that's not in the layer.
+ */
+export const packLambda = async ({ sourceFile, zipFile, debug, progress, }) => {
+    const lambdaFiles = [sourceFile, ...findDependencies(sourceFile)];
+    const zipfile = new yazl.ZipFile();
+    const stripCommon = removeCommonAncestor(commonParent(lambdaFiles));
+    for (const file of lambdaFiles) {
+        const compiled = (await swc.transformFile(file, {
+            jsc: {
+                target: 'es2022',
+            },
+        })).code;
+        debug?.(`compiled`, compiled);
+        const jsFileName = stripCommon(file);
+        zipfile.addBuffer(Buffer.from(compiled, 'utf-8'), jsFileName);
+        progress?.(`added`, jsFileName);
+    }
+    const hash = await checkSumOfFiles([
+        ...lambdaFiles,
+        // Include this script, so artefact is updated if the way it's built is changed
+        fileURLToPath(import.meta.url),
+    ]);
+    // Mark it as ES module
+    zipfile.addBuffer(Buffer.from(JSON.stringify({
+        type: 'module',
+    }), 'utf-8'), 'package.json');
+    progress?.(`added`, 'package.json');
+    await new Promise((resolve) => {
+        zipfile.outputStream.pipe(createWriteStream(zipFile)).on('close', () => {
+            resolve();
+        });
+        zipfile.end();
+    });
+    progress?.(`written`, zipFile);
+    return { handler: stripCommon(sourceFile), hash };
+};

package/dist/packLambdaFromPath.d.ts

@@ -0,0 +1,2 @@
+import { type PackedLambda } from './packLambda.js';
+export declare const packLambdaFromPath: (id: string, sourceFile: string, handlerFunction?: string, baseDir?: string) => Promise<PackedLambda>;

package/dist/packLambdaFromPath.js

@@ -0,0 +1,24 @@
+import { mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { packLambda } from './packLambda.js';
+export const packLambdaFromPath = async (id, sourceFile, handlerFunction = 'handler', baseDir = process.cwd()) => {
+    try {
+        await mkdir(path.join(process.cwd(), 'dist', 'lambdas'), {
+            recursive: true,
+        });
+    }
+    catch {
+        // Directory exists
+    }
+    const zipFile = path.join(process.cwd(), 'dist', 'lambdas', `${id}.zip`);
+    const { handler, hash } = await packLambda({
+        sourceFile: path.join(baseDir, sourceFile),
+        zipFile,
+    });
+    return {
+        id,
+        zipFile,
+        handler: handler.replace('.js', `.${handlerFunction}`),
+        hash,
+    };
+};

package/dist/packLayer.d.ts

@@ -0,0 +1,8 @@
+export type PackedLayer = {
+    layerZipFile: string;
+    hash: string;
+};
+export declare const packLayer: ({ id, dependencies, }: {
+    id: string;
+    dependencies: string[];
+}) => Promise<PackedLayer>;

package/dist/packLayer.js

@@ -0,0 +1,85 @@
+import { spawn } from 'child_process';
+import { createWriteStream } from 'fs';
+import { copyFile, mkdir, readFile, rm, writeFile } from 'fs/promises';
+import { glob } from 'glob';
+import path from 'path';
+import { ZipFile } from 'yazl';
+import { checkSumOfFiles, checkSumOfStrings } from './checksumOfFiles.js';
+import { fileURLToPath } from 'node:url';
+export const packLayer = async ({ id, dependencies, }) => {
+    const packageJsonFile = path.join(process.cwd(), 'package.json');
+    const packageLockJsonFile = path.join(process.cwd(), 'package-lock.json');
+    const { dependencies: deps, devDependencies: devDeps } = JSON.parse(await readFile(packageJsonFile, 'utf-8'));
+    const layerDir = path.join(process.cwd(), 'dist', 'layers', id);
+    const nodejsDir = path.join(layerDir, 'nodejs');
+    try {
+        await rm(layerDir, { recursive: true });
+    }
+    catch {
+        // Folder does not exist.
+    }
+    await mkdir(nodejsDir, { recursive: true });
+    const depsToBeInstalled = dependencies.reduce((resolved, dep) => {
+        const resolvedDependency = deps[dep] ?? devDeps[dep];
+        if (resolvedDependency === undefined)
+            throw new Error(`Could not resolve dependency "${dep}" in ${packageJsonFile}!`);
+        return {
+            ...resolved,
+            [dep]: resolvedDependency,
+        };
+    }, {});
+    const packageJSON = path.join(nodejsDir, 'package.json');
+    await writeFile(packageJSON, JSON.stringify({
+        dependencies: depsToBeInstalled,
+    }), 'utf-8');
+    const packageLock = path.join(nodejsDir, 'package-lock.json');
+    await copyFile(packageLockJsonFile, packageLock);
+    await new Promise((resolve, reject) => {
+        const [cmd, ...args] = [
+            'npm',
+            'ci',
+            '--ignore-scripts',
+            '--only=prod',
+            '--no-audit',
+        ];
+        const p = spawn(cmd, args, {
+            cwd: nodejsDir,
+        });
+        p.on('close', (code) => {
+            if (code !== 0) {
+                const msg = `${cmd} ${args.join(' ')} in ${nodejsDir} exited with code ${code}.`;
+                return reject(new Error(msg));
+            }
+            return resolve();
+        });
+    });
+    const filesToAdd = await glob(`**`, {
+        cwd: layerDir,
+        nodir: true,
+    });
+    const zipfile = new ZipFile();
+    filesToAdd.forEach((f) => {
+        zipfile.addFile(path.join(layerDir, f), f);
+    });
+    const zipFileName = await new Promise((resolve) => {
+        const zipFileName = path.join(process.cwd(), 'dist', 'layers', `${id}.zip`);
+        zipfile.outputStream
+            .pipe(createWriteStream(zipFileName))
+            .on('close', () => {
+            resolve(zipFileName);
+        });
+        zipfile.end();
+    });
+    return {
+        layerZipFile: zipFileName,
+        hash: checkSumOfStrings([
+            JSON.stringify(dependencies),
+            await checkSumOfFiles([
+                packageJSON,
+                packageLock,
+                // Include this script, so artefact is updated if the way it's built is changed
+                fileURLToPath(import.meta.url),
+            ]),
+        ]),
+    };
+};

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@bifravst/aws-cdk-lambda-helpers",
+  "version": "1.0.0",
+  "description": "Helper functions which simplify working with TypeScript lambdas for AWS CDK.",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "node": "./dist/index.js"
+    }
+  },
+  "type": "module",
+  "scripts": {
+    "test": "tsx --no-warnings --test ./src/*.spec.ts",
+    "prepare": "husky",
+    "prepublishOnly": "npx tsc --noEmit false --outDir ./dist -d"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bifravst/aws-cdk-lambda-helpers.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bifravst/aws-cdk-lambda-helpers/issues"
+  },
+  "homepage": "https://github.com/bifravst/aws-cdk-lambda-helpers",
+  "keywords": [
+    "aws",
+    "cdk",
+    "lambda",
+    "typescript"
+  ],
+  "author": "Nordic Semiconductor ASA | nordicsemi.no",
+  "license": "BSD-3-Clause",
+  "devDependencies": {
+    "@bifravst/eslint-config-typescript": "6.0.17",
+    "@bifravst/prettier-config": "1.0.0",
+    "@commitlint/config-conventional": "19.1.0",
+    "@types/node": "20.12.3",
+    "@types/yazl": "2.4.5",
+    "husky": "9.0.11",
+    "tsx": "4.7.1"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "prettier --write",
+      "eslint"
+    ],
+    "*.{md,json,yaml,yml}": [
+      "prettier --write"
+    ]
+  },
+  "engines": {
+    "node": ">=20",
+    "npm": ">=9"
+  },
+  "release": {
+    "branches": [
+      "saga",
+      {
+        "name": "!(saga)",
+        "prerelease": true
+      }
+    ],
+    "remoteTags": true,
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      [
+        "@semantic-release/github",
+        {
+          "successComment": false,
+          "failTitle": false
+        }
+      ]
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "package-lock.json",
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "prettier": "@bifravst/prettier-config",
+  "dependencies": {
+    "@swc/core": "1.4.11",
+    "glob": "10.3.12",
+    "yazl": "2.5.1"
+  }
+}