@bifravst/aws-cdk-lambda-helpers 5.0.0 → 5.0.1

package/dist/layers/baseLayer/nodejs/package.json

@@ -0,0 +1 @@
+{"dependencies":{"id128":"1.6.6","fp-ts":"2.16.11"}}

package/dist/package.json

@@ -0,0 +1,132 @@
+{
+    "name": "@bifravst/aws-cdk-lambda-helpers",
+    "version": "5.0.1",
+    "description": "Helper functions which simplify working with TypeScript lambdas for AWS CDK.",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./dist/src/lambda.d.ts",
+                "default": "./dist/src/lambda.js"
+            }
+        },
+        "./layer": {
+            "import": {
+                "types": "./dist/src/layer.d.ts",
+                "default": "./dist/src/layer.js"
+            }
+        },
+        "./util": {
+            "import": {
+                "types": "./dist/src/util.d.ts",
+                "default": "./dist/src/util.js"
+            }
+        },
+        "./cdk": {
+            "import": {
+                "types": "./dist/src/cdk.d.ts",
+                "default": "./dist/src/cdk.js"
+            }
+        }
+    },
+    "type": "module",
+    "scripts": {
+        "test": "node --experimental-strip-types --no-warnings --test ./src/*.spec.ts",
+        "test:e2e": "node --experimental-strip-types --test e2e.spec.ts",
+        "test:e2e:updated": "node --experimental-strip-types --test e2e-updated.spec.ts",
+        "prepare": "husky && case \"$npm_command\" in install|ci) check-node-version --package ;; esac",
+        "prepublishOnly": "npx tsc --noEmit false -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": {
+        "@aws-sdk/client-cloudformation": "3.1111.0",
+        "@aws-sdk/client-dynamodb": "3.1111.0",
+        "@bifravst/cloudformation-helpers": "10.0.0",
+        "@bifravst/eslint-config-typescript": "8.0.0",
+        "@bifravst/from-env": "4.0.0",
+        "@bifravst/prettier-config": "2.0.0",
+        "@commitlint/config-conventional": "21.2.2",
+        "@swc/cli": "0.8.1",
+        "@types/aws-lambda": "8.10.162",
+        "@types/node": "26.2.0",
+        "@types/unzip-stream": "0.3.4",
+        "@types/yazl": "3.3.1",
+        "@typescript/native": "npm:typescript@7.0.2",
+        "cdk": "2.1136.0",
+        "check-node-version": "4.2.1",
+        "commitlint": "21.2.2",
+        "husky": "9.1.7",
+        "id128": "1.6.6",
+        "lint-staged": "17.3.0",
+        "unzip-stream": "0.3.4",
+        "typescript": "npm:@typescript/typescript6@6.0.2"
+    },
+    "lint-staged": {
+        "*.ts": [
+            "prettier --write",
+            "eslint"
+        ],
+        "*.{md,json,yaml,yml}": [
+            "prettier --write"
+        ]
+    },
+    "engines": {
+        "node": ">=24.19.0 <25",
+        "npm": ">=12.0.2 <13"
+    },
+    "release": {
+        "branches": [
+            "saga"
+        ],
+        "remoteTags": true,
+        "plugins": [
+            "@semantic-release/commit-analyzer",
+            "@semantic-release/release-notes-generator",
+            "@semantic-release/npm",
+            [
+                "@semantic-release/github",
+                {
+                    "successCommentCondition": false,
+                    "failTitle": false
+                }
+            ]
+        ]
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist",
+        "LICENSE",
+        "README.md"
+    ],
+    "prettier": "@bifravst/prettier-config",
+    "dependencies": {
+        "@swc/core": "1.16.0",
+        "fp-ts": "2.16.11",
+        "p-retry": "8.0.0",
+        "typescript": "7.0.2",
+        "yazl": "3.3.1"
+    },
+    "peerDependencies": {
+        "@aws-sdk/client-lambda": "^3.1111.0",
+        "@bifravst/aws-ssm-settings-helpers": "2.x",
+        "aws-cdk-lib": "^2.265.0",
+        "chalk": "6.x",
+        "constructs": "^10.8.1"
+    }
+}

package/dist/src/IoTActionRole.d.ts

@@ -0,0 +1,10 @@
+import { aws_iam as IAM } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+/**
+ * Base role for IoT Actions that allows to publish to the 'errors' topic
+ */
+export declare class IoTActionRole extends Construct {
+    readonly role: IAM.IRole;
+    readonly roleArn: string;
+    constructor(parent: Construct);
+}

package/dist/src/IoTActionRole.js

@@ -0,0 +1,28 @@
+import { aws_iam as IAM, Stack } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+/**
+ * Base role for IoT Actions that allows to publish to the 'errors' topic
+ */
+export class IoTActionRole extends Construct {
+    role;
+    roleArn;
+    constructor(parent) {
+        super(parent, 'errorActionRole');
+        this.role = new IAM.Role(this, 'iot-action-role', {
+            assumedBy: new IAM.ServicePrincipal('iot.amazonaws.com'),
+            inlinePolicies: {
+                rootPermissions: new IAM.PolicyDocument({
+                    statements: [
+                        new IAM.PolicyStatement({
+                            actions: ['iot:Publish'],
+                            resources: [
+                                `arn:aws:iot:${Stack.of(this).region}:${Stack.of(this).account}:topic/errors`,
+                            ],
+                        }),
+                    ],
+                }),
+            },
+        });
+        this.roleArn = this.role.roleArn;
+    }
+}

package/dist/src/LambdaLogGroup.d.ts

@@ -0,0 +1,6 @@
+import { aws_logs as Logs } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+export declare class LambdaLogGroup extends Construct {
+    readonly logGroup: Logs.LogGroup;
+    constructor(parent: Construct, id: string, retention?: Logs.RetentionDays);
+}

package/dist/src/LambdaLogGroup.js

@@ -0,0 +1,22 @@
+import { aws_logs as Logs, Names, RemovalPolicy, Stack } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { isTest } from './isTest.js';
+export class LambdaLogGroup extends Construct {
+    logGroup;
+    constructor(parent, id, 
+    // Defaults to 30 days for production, 1 day for test
+    retention) {
+        super(parent, id);
+        this.logGroup = new Logs.LogGroup(this, 'logGroup', {
+            retention: retention ??
+                (isTest(this)
+                    ? Logs.RetentionDays.ONE_DAY
+                    : Logs.RetentionDays.ONE_MONTH),
+            logGroupName: `/${Stack.of(this).stackName}/fn/${id}-${Names.uniqueId(this)}`,
+            logGroupClass: Logs.LogGroupClass.STANDARD, // INFREQUENT_ACCESS does not support custom metrics
+            removalPolicy: this.node.getContext('isTest') === true
+                ? RemovalPolicy.DESTROY
+                : RemovalPolicy.RETAIN,
+        });
+    }
+}

package/dist/src/LambdaSource.d.ts

@@ -0,0 +1,7 @@
+import { aws_lambda as Lambda } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import type { PackedLambda } from './packLambda.ts';
+export declare class LambdaSource extends Construct {
+    readonly code: Lambda.AssetCode;
+    constructor(parent: Construct, packedLambda: Pick<PackedLambda, 'zipFilePath' | 'id' | 'hash'>);
+}

package/dist/src/LambdaSource.js

@@ -0,0 +1,12 @@
+import { AssetHashType, aws_lambda as Lambda } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+export class LambdaSource extends Construct {
+    code;
+    constructor(parent, packedLambda) {
+        super(parent, `${packedLambda.id}Source`);
+        this.code = Lambda.Code.fromAsset(packedLambda.zipFilePath, {
+            assetHash: packedLambda.hash,
+            assetHashType: AssetHashType.CUSTOM,
+        });
+    }
+}

package/dist/src/PackedLambdaFn.d.ts

@@ -0,0 +1,25 @@
+import { Function as LambdaFunction, type FunctionProps } from 'aws-cdk-lib/aws-lambda';
+import type { ILogGroupRef } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+import type { PackedLambda } from './packLambda.ts';
+/**
+ * Creates a Lambda function with useful defaults:
+ *
+ * - Code from a PackedLambda
+ * - Architecture: ARM64
+ * - Runtime: Node.js 20
+ * - timeout: 5 seconds
+ * - memorySize: 1792 MB
+ * - environment
+ *   VERSION: set from the 'version' context
+ *   NODE_NO_WARNINGS: disabled to get rid of Node.js warnings in the logs
+ *   STACK_NAME: the current stack name
+ *   DISABLE_METRICS: set to '1' of 'isTest'===true in the context
+ * - a LambdaLogGroup (if not provided)
+ * - policies that allow to access all SSM parameters below the current stack name
+ */
+export declare class PackedLambdaFn extends Construct {
+    readonly fn: LambdaFunction;
+    readonly logGroup: ILogGroupRef;
+    constructor(parent: Construct, id: string, source: PackedLambda, props: Partial<Omit<FunctionProps, 'code' | 'handler'>>);
+}

package/dist/src/PackedLambdaFn.js

@@ -0,0 +1,55 @@
+import { Permissions as SettingsPermissions } from '@bifravst/aws-ssm-settings-helpers/cdk';
+import { Duration, Stack, Tags } from 'aws-cdk-lib';
+import { Architecture, Function as LambdaFunction, Runtime, } from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+import { LambdaLogGroup } from './LambdaLogGroup.js';
+import { LambdaSource } from './LambdaSource.js';
+/**
+ * Creates a Lambda function with useful defaults:
+ *
+ * - Code from a PackedLambda
+ * - Architecture: ARM64
+ * - Runtime: Node.js 20
+ * - timeout: 5 seconds
+ * - memorySize: 1792 MB
+ * - environment
+ *   VERSION: set from the 'version' context
+ *   NODE_NO_WARNINGS: disabled to get rid of Node.js warnings in the logs
+ *   STACK_NAME: the current stack name
+ *   DISABLE_METRICS: set to '1' of 'isTest'===true in the context
+ * - a LambdaLogGroup (if not provided)
+ * - policies that allow to access all SSM parameters below the current stack name
+ */
+export class PackedLambdaFn extends Construct {
+    fn;
+    logGroup;
+    constructor(parent, id, source, props) {
+        super(parent, id);
+        const { environment, initialPolicy, architecture, ...rest } = props;
+        this.logGroup =
+            props.logGroup ?? new LambdaLogGroup(this, 'fnLogs').logGroup;
+        this.fn = new LambdaFunction(this, 'fn', {
+            architecture: architecture ?? Architecture.ARM_64,
+            runtime: props.runtime ?? Runtime.NODEJS_24_X,
+            timeout: Duration.seconds(5),
+            memorySize: 1792,
+            environment: {
+                VERSION: this.node.tryGetContext('version'),
+                NODE_NO_WARNINGS: '1',
+                STACK_NAME: Stack.of(this).stackName,
+                DISABLE_METRICS: this.node.tryGetContext('isTest') === true ? '1' : '0',
+                ...environment,
+            },
+            initialPolicy: [
+                ...(initialPolicy ?? []),
+                SettingsPermissions(Stack.of(this)),
+            ],
+            ...rest,
+            logGroup: this.logGroup,
+            handler: source.handler,
+            code: new LambdaSource(this, source).code,
+        });
+        Tags.of(this.fn).add('packedLambda:id', source.id);
+        Tags.of(this.fn).add('packedLambda:hash', source.hash);
+    }
+}

package/dist/src/cdk.d.ts

@@ -0,0 +1,4 @@
+export * from './IoTActionRole.ts';
+export * from './LambdaLogGroup.ts';
+export * from './LambdaSource.ts';
+export * from './PackedLambdaFn.ts';

package/dist/src/cdk.js

@@ -0,0 +1,4 @@
+export * from './IoTActionRole.js';
+export * from './LambdaLogGroup.js';
+export * from './LambdaSource.js';
+export * from './PackedLambdaFn.js';

package/dist/src/checkSumOfFiles.spec.d.ts

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

package/dist/src/checkSumOfFiles.spec.js

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+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/src/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/src/checksumOfFiles.js

@@ -0,0 +1,40 @@
+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 (filePath) => {
+    hashCache[filePath] ??= await new Promise((resolve) => {
+        const hash = crypto.createHash('sha1');
+        hash.setEncoding('hex');
+        const fileStream = fs.createReadStream(filePath);
+        fileStream.pipe(hash, { end: false });
+        fileStream.on('end', () => {
+            hash.end();
+            const h = hash.read().toString();
+            resolve(h);
+        });
+    });
+    return hashCache[filePath];
+};
+/**
+ * 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/src/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/src/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/src/commonParent.spec.d.ts

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

package/dist/src/commonParent.spec.js

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+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/src/findDependencies.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Resolve project-level dependencies for the given file using TypeScript compiler API
+ */
+export declare const findDependencies: (args: {
+    sourceFilePath: string;
+    imports?: string[];
+    visited?: string[];
+    packages?: Set<string>;
+    tsConfigFilePath?: string;
+    importsSubpathPatterns?: Record<string, string>;
+}) => {
+    dependencies: string[];
+    /**
+     * A map of import subpath patterns to their resolved paths
+     * @see https://nodejs.org/api/packages.html#subpath-patterns
+     */
+    importsSubpathPatterns: Record<string, string>;
+    /**
+     * The external packages that the source file depends on
+     */
+    packages: Set<string>;
+};

package/dist/src/findDependencies.js

@@ -0,0 +1,114 @@
+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 = (args) => {
+    const sourceFilePath = args.sourceFilePath;
+    const visited = args.visited ?? [];
+    const dependencies = args.imports ?? [];
+    const packages = args.packages ?? new Set();
+    const importsSubpathPatterns = args.importsSubpathPatterns ?? {};
+    if (visited.includes(sourceFilePath))
+        return {
+            dependencies,
+            importsSubpathPatterns,
+            packages,
+        };
+    const tsConfigFilePath = args.tsConfigFilePath;
+    const tsConfig = tsConfigFilePath !== undefined
+        ? JSON.parse(readFileSync(tsConfigFilePath, 'utf-8').toString())
+        : undefined;
+    const fileNode = ts.createSourceFile(sourceFilePath, readFileSync(sourceFilePath, 'utf-8').toString(), ts.ScriptTarget.ES2022, 
+    /*setParentNodes */ true);
+    const parseChild = (node) => {
+        if (node.kind !== ts.SyntaxKind.ImportDeclaration &&
+            node.kind !== ts.SyntaxKind.ExportDeclaration)
+            return;
+        const moduleSpecifier = node.moduleSpecifier.text;
+        const { resolvedPath: file } = resolve({
+            moduleSpecifier,
+            sourceFilePath,
+            tsConfigFilePath,
+            tsConfig,
+            importsSubpathPatterns,
+        });
+        try {
+            const s = statSync(file);
+            if (!s.isDirectory())
+                dependencies.push(file);
+        }
+        catch {
+            // Module or file not found
+            visited.push(file);
+            packages.add(moduleSpecifier);
+        }
+    };
+    ts.forEachChild(fileNode, parseChild);
+    visited.push(sourceFilePath);
+    for (const file of dependencies) {
+        findDependencies({
+            sourceFilePath: file,
+            imports: dependencies,
+            visited,
+            tsConfigFilePath,
+            importsSubpathPatterns,
+            packages,
+        });
+    }
+    return {
+        dependencies,
+        importsSubpathPatterns,
+        packages: new Set([
+            ...packages.difference(new Set([
+                'aws-lambda', // Ignore type-only package
+            ])),
+        ]
+            .filter((p) => !p.startsWith('node:'))
+            .filter((p) => !p.startsWith('@aws-sdk/'))
+            .map((d) => {
+            if (d.startsWith('@')) {
+                const [org, packageName] = d.split('/');
+                return `${org}/${packageName}`;
+            }
+            return d.split('/')[0];
+        })),
+    };
+};
+const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig, importsSubpathPatterns, }) => {
+    if (moduleSpecifier.startsWith('.'))
+        return {
+            resolvedPath: path.resolve(path.parse(sourceFilePath).dir, moduleSpecifier),
+        };
+    if (tsConfigFilePath !== undefined &&
+        tsConfig?.compilerOptions?.paths !== undefined) {
+        for (const [key, value] of Object.entries(tsConfig.compilerOptions.paths)) {
+            const [resolvedPath] = value;
+            if (resolvedPath === undefined)
+                continue;
+            // Exact match
+            if (moduleSpecifier === key) {
+                const fullResolvedPath = path.join(path.parse(tsConfigFilePath).dir, resolvedPath);
+                importsSubpathPatterns[key] = resolvedPath;
+                return {
+                    resolvedPath: fullResolvedPath,
+                };
+            }
+            // Wildcard match
+            if (!key.includes('*'))
+                continue;
+            const rx = new RegExp(`^${key.replace('*', '(?<wildcard>.*)')}`);
+            const maybeMatch = rx.exec(moduleSpecifier);
+            if (maybeMatch?.groups?.wildcard === undefined)
+                continue;
+            importsSubpathPatterns[key] = resolvedPath;
+            return {
+                resolvedPath: path.resolve(path.parse(tsConfigFilePath).dir, resolvedPath.replace('*', maybeMatch.groups.wildcard)),
+            };
+        }
+    }
+    return {
+        resolvedPath: moduleSpecifier,
+    };
+};

package/dist/src/findDependencies.spec.d.ts

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

package/dist/src/findDependencies.spec.js

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { URL } from 'node:url';
+import { findDependencies } from './findDependencies.js';
+const __dirname = new URL('.', import.meta.url).pathname;
+void describe('findDependencies()', () => {
+    void it('should return a list of external dependencies', () => {
+        const { packages } = findDependencies({
+            sourceFilePath: path.join(__dirname, '..', 'cdk', 'lambda.ts'),
+        });
+        assert.equal(packages.has('id128'), true, "Should include the 'id128' package");
+        assert.equal(packages.has('aws-lambda'), false, "Should not include the type-only 'aws-lambda' package");
+        assert.equal(packages.has('node:crypto'), false, 'Should not include built-in node dependencies');
+        assert.equal(packages.has('fp-ts'), true, 'Should include the top-level package only');
+        assert.equal(packages.has('@aws-sdk/client-dynamodb'), false, 'Should not include AWS SDK packages');
+    });
+    void it('should honor tsconfig.json paths', () => {
+        const { dependencies } = findDependencies({
+            sourceFilePath: path.join(__dirname, 'test-data', 'resolve-paths', 'lambda.ts'),
+            tsConfigFilePath: path.join(__dirname, 'test-data', 'resolve-paths', 'tsconfig.json'),
+        });
+        assert.equal(dependencies.includes(path.join(__dirname, 'test-data', 'resolve-paths', 'foo', 'index.ts')), true, 'Should include the index.ts file');
+        assert.equal(dependencies.includes(path.join(__dirname, 'test-data', 'resolve-paths', 'foo', '1.ts')), true, 'Should include the module referenced in the index.ts file');
+        assert.equal(dependencies.includes(path.join(__dirname, 'test-data', 'resolve-paths', 'foo', '2.ts')), true, 'Should include the module file');
+    });
+    void it('should return an import map', () => {
+        const { importsSubpathPatterns } = findDependencies({
+            sourceFilePath: path.join(__dirname, 'test-data', 'resolve-paths', 'lambda.ts'),
+            tsConfigFilePath: path.join(__dirname, 'test-data', 'resolve-paths', 'tsconfig.json'),
+        });
+        assert.deepEqual(importsSubpathPatterns, {
+            '#foo': './foo/index.ts',
+            '#foo/*': './foo/*',
+        });
+    });
+});

package/dist/src/isTest.d.ts

@@ -0,0 +1,2 @@
+import type { Construct } from 'constructs';
+export declare const isTest: (construct: Construct) => boolean;

package/dist/src/isTest.js

@@ -0,0 +1 @@
+export const isTest = (construct) => construct.node.tryGetContext('isTest') === true;

package/dist/src/isTest.spec.d.ts

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

package/dist/src/isTest.spec.js

@@ -0,0 +1,16 @@
+import assert from 'node:assert';
+import { describe, it, mock } from 'node:test';
+import { isTest } from './isTest.js';
+void describe('isTest()', () => {
+    void it('should return true if the construct is a test', () => {
+        const construct = {
+            node: {
+                tryGetContext: mock.fn(() => true),
+            },
+        };
+        const result = isTest(construct);
+        assert.equal(result, true);
+        assert.equal(construct.node.tryGetContext.mock.calls.length, 1);
+        assert.equal(construct.node.tryGetContext.mock.calls[0]?.arguments[0], 'isTest');
+    });
+});

package/dist/src/lambda.d.ts

@@ -0,0 +1,2 @@
+export * from './packLambda.ts';
+export * from './packLambdaFromPath.ts';

package/dist/src/lambda.js

@@ -0,0 +1,2 @@
+export * from './packLambda.js';
+export * from './packLambdaFromPath.js';