@bifravst/aws-cdk-lambda-helpers 2.3.10 → 3.0.1

package/dist/src/IoTActionRole.js

@@ -2,11 +2,10 @@ 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 {
+ */ export class IoTActionRole extends Construct {
     role;
     roleArn;
-    constructor(parent) {
+    constructor(parent){
         super(parent, 'errorActionRole');
         this.role = new IAM.Role(this, 'iot-action-role', {
             assumedBy: new IAM.ServicePrincipal('iot.amazonaws.com'),
@@ -14,14 +13,16 @@ export class IoTActionRole extends Construct {
                 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`,
+                            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.js

@@ -3,20 +3,14 @@ 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) {
+    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),
+            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,
+            logGroupClass: Logs.LogGroupClass.STANDARD,
+            removalPolicy: this.node.getContext('isTest') === true ? RemovalPolicy.DESTROY : RemovalPolicy.RETAIN
         });
     }
 }

package/dist/src/LambdaSource.d.ts

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

package/dist/src/LambdaSource.js

@@ -1,13 +1,13 @@
-import { AssetHashType, aws_lambda as Lambda, aws_s3 as S3, aws_s3_assets as S3Assets, } from 'aws-cdk-lib';
+import { AssetHashType, aws_lambda as Lambda, aws_s3 as S3, aws_s3_assets as S3Assets } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 export class LambdaSource extends Construct {
     code;
-    constructor(parent, packedLambda) {
+    constructor(parent, packedLambda){
         super(parent, `${packedLambda.id}Source`);
         const asset = new S3Assets.Asset(this, 'asset', {
             path: packedLambda.zipFilePath,
             assetHash: packedLambda.hash,
-            assetHashType: AssetHashType.CUSTOM,
+            assetHashType: AssetHashType.CUSTOM
         });
         const sourceCodeBucket = S3.Bucket.fromBucketName(this, 'bucket', asset.s3BucketName);
         this.code = Lambda.Code.fromBucket(sourceCodeBucket, asset.s3ObjectKey);

package/dist/src/PackedLambdaFn.d.ts

@@ -1,6 +1,6 @@
 import { aws_lambda as Lambda, type aws_logs as Logs } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import type { PackedLambda } from './packLambda.js';
+import type { PackedLambda } from './packLambda.ts';
 /**
  * Creates a Lambda function with useful defaults:
  *

package/dist/src/PackedLambdaFn.js

@@ -1,5 +1,5 @@
 import { Permissions as SettingsPermissions } from '@bifravst/aws-ssm-settings-helpers/cdk';
-import { Duration, aws_lambda as Lambda, Stack, } from 'aws-cdk-lib';
+import { Duration, aws_lambda as Lambda, Stack } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import { LambdaLogGroup } from './LambdaLogGroup.js';
 import { LambdaSource } from './LambdaSource.js';
@@ -18,15 +18,13 @@ import { LambdaSource } from './LambdaSource.js';
  *   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 {
+ */ export class PackedLambdaFn extends Construct {
     fn;
     logGroup;
-    constructor(parent, id, source, props) {
+    constructor(parent, id, source, props){
         super(parent, id);
         const { environment, initialPolicy, ...rest } = props;
-        this.logGroup =
-            props.logGroup ?? new LambdaLogGroup(this, 'fnLogs').logGroup;
+        this.logGroup = props.logGroup ?? new LambdaLogGroup(this, 'fnLogs').logGroup;
         this.fn = new Lambda.Function(this, 'fn', {
             architecture: Lambda.Architecture.ARM_64,
             runtime: props.runtime ?? Lambda.Runtime.NODEJS_22_X,
@@ -39,16 +37,16 @@ export class PackedLambdaFn extends Construct {
                 DISABLE_METRICS: this.node.tryGetContext('isTest') === true ? '1' : '0',
                 PACKED_LAMBDA_ID: source.id,
                 PACKED_LAMBDA_HASH: source.hash,
-                ...environment,
+                ...environment
             },
             initialPolicy: [
-                ...(initialPolicy ?? []),
-                SettingsPermissions(Stack.of(this)),
+                ...initialPolicy ?? [],
+                SettingsPermissions(Stack.of(this))
             ],
             ...rest,
             logGroup: this.logGroup,
             handler: source.handler,
-            code: new LambdaSource(this, source).code,
+            code: new LambdaSource(this, source).code
         });
         this.fn.node.addMetadata('packedLambda:id', source.id);
         this.fn.node.addMetadata('packedLambda:hash', source.hash);

package/dist/src/cdk.d.ts

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

package/dist/src/checkSumOfFiles.spec.js

@@ -2,15 +2,14 @@ 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'));
+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.js

@@ -2,26 +2,29 @@ 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) => {
+ */ export const checkSumOfFiles = async (files)=>{
     const fileChecksums = await checkSum(files);
-    const checksum = checkSumOfStrings([...Object.entries(fileChecksums)].map(([, hash]) => hash));
+    const checksum = checkSumOfStrings([
+        ...Object.entries(fileChecksums)
+    ].map(([, hash])=>hash));
     return checksum;
 };
-export const checkSumOfStrings = (strings) => {
+export const checkSumOfStrings = (strings)=>{
     const hash = crypto.createHash('sha1');
     hash.update(strings.join(''));
     return hash.digest('hex');
 };
 const hashCache = {};
-const hashFile = async (filePath) => {
+const hashFile = async (filePath)=>{
     if (hashCache[filePath] === undefined) {
-        hashCache[filePath] = await new Promise((resolve) => {
+        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', () => {
+            fileStream.pipe(hash, {
+                end: false
+            });
+            fileStream.on('end', ()=>{
                 hash.end();
                 const h = hash.read().toString();
                 resolve(h);
@@ -32,11 +35,10 @@ const hashFile = async (filePath) => {
 };
 /**
  * Computes the checksum for the given files
- */
-const checkSum = async (files) => {
+ */ const checkSum = async (files)=>{
     const hashes = {};
-    await files.reduce(async (p, file) => p.then(async () => {
-        hashes[file] = await hashFile(file);
-    }), Promise.resolve());
+    await files.reduce(async (p, file)=>p.then(async ()=>{
+            hashes[file] = await hashFile(file);
+        }), Promise.resolve());
     return hashes;
 };

package/dist/src/commonParent.js

@@ -1,13 +1,11 @@
 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;
+ */ 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) {
+    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.js

@@ -1,20 +1,22 @@
 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/'));
+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.js

@@ -1,45 +1,36 @@
 import { readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
-import ts, {} from 'typescript';
+import ts from 'typescript';
 /**
  * Resolve project-level dependencies for the given file using TypeScript compiler API
- */
-export const findDependencies = (args) => {
+ */ 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,
-        };
+    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 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,
+            importsSubpathPatterns
         });
         try {
             const s = statSync(file);
-            if (!s.isDirectory())
-                dependencies.push(file);
-        }
-        catch {
+            if (!s.isDirectory()) dependencies.push(file);
+        } catch  {
             // Module or file not found
             visited.push(file);
             packages.add(moduleSpecifier);
@@ -47,14 +38,14 @@ export const findDependencies = (args) => {
     };
     ts.forEachChild(fileNode, parseChild);
     visited.push(sourceFilePath);
-    for (const file of dependencies) {
+    for (const file of dependencies){
         findDependencies({
             sourceFilePath: file,
             imports: dependencies,
             visited,
             tsConfigFilePath,
             importsSubpathPatterns,
-            packages,
+            packages
         });
     }
     return {
@@ -62,71 +53,53 @@ export const findDependencies = (args) => {
         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) => {
+                'aws-lambda'
+            ]))
+        ].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)
-                // 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'),
-        };
-    if (tsConfigFilePath !== undefined &&
-        tsConfig?.compilerOptions?.paths !== undefined) {
-        for (const [key, value] of Object.entries(tsConfig.compilerOptions.paths)) {
+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;
+            if (resolvedPath === undefined) continue;
             // Exact match
             if (moduleSpecifier === key) {
                 const fullResolvedPath = path.join(path.parse(tsConfigFilePath).dir, tsConfig.compilerOptions.baseUrl, resolvedPath);
                 importsSubpathPatterns[key] = [
                     tsConfig.compilerOptions.baseUrl,
                     path.sep,
-                    resolvedPath.replace(/\.ts$/, '.js'),
+                    resolvedPath
                 ].join('');
                 return {
-                    resolvedPath: fullResolvedPath,
+                    resolvedPath: fullResolvedPath
                 };
             }
             // Wildcard match
-            if (!key.includes('*'))
-                continue;
+            if (!key.includes('*')) continue;
             const rx = new RegExp(`^${key.replace('*', '(?<wildcard>.*)')}`);
             const maybeMatch = rx.exec(moduleSpecifier);
-            if (maybeMatch?.groups?.wildcard === undefined)
-                continue;
+            if (maybeMatch?.groups?.wildcard === undefined) continue;
             importsSubpathPatterns[key] = [
                 tsConfig.compilerOptions.baseUrl,
                 path.sep,
-                resolvedPath.replace(/\.ts$/, '.js'),
+                resolvedPath
             ].join('');
             return {
-                resolvedPath: path
-                    .resolve(path.parse(tsConfigFilePath).dir, tsConfig.compilerOptions.baseUrl, resolvedPath.replace('*', maybeMatch.groups.wildcard))
-                    // Same as above, replace `.js` with `.ts`
-                    .replace(/\.js$/, '.ts'),
+                resolvedPath: path.resolve(path.parse(tsConfigFilePath).dir, tsConfig.compilerOptions.baseUrl, resolvedPath.replace('*', maybeMatch.groups.wildcard))
             };
         }
     }
     return {
-        resolvedPath: moduleSpecifier,
+        resolvedPath: moduleSpecifier
     };
 };

package/dist/src/findDependencies.spec.js

@@ -4,10 +4,10 @@ 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', () => {
+void describe('findDependencies()', ()=>{
+    void it('should return a list of external dependencies', ()=>{
         const { packages } = findDependencies({
-            sourceFilePath: path.join(__dirname, '..', 'cdk', 'lambda.ts'),
+            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");
@@ -15,23 +15,23 @@ void describe('findDependencies()', () => {
         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', () => {
+    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'),
+            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', () => {
+    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'),
+            tsConfigFilePath: path.join(__dirname, 'test-data', 'resolve-paths', 'tsconfig.json')
         });
         assert.deepEqual(importsSubpathPatterns, {
-            '#foo': './foo/index.js',
-            '#foo/*': './foo/*',
+            '#foo': './foo/index.ts',
+            '#foo/*': './foo/*'
         });
     });
 });

package/dist/src/isTest.js

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

package/dist/src/isTest.spec.js

@@ -1,12 +1,12 @@
 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', () => {
+void describe('isTest()', ()=>{
+    void it('should return true if the construct is a test', ()=>{
         const construct = {
             node: {
-                tryGetContext: mock.fn(() => true),
-            },
+                tryGetContext: mock.fn(()=>true)
+            }
         };
         const result = isTest(construct);
         assert.equal(result, true);

package/dist/src/lambda.d.ts

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

package/dist/src/layer.d.ts

@@ -1 +1 @@
-export * from './packLayer.js';
+export * from './packLayer.ts';

package/dist/src/module-folder-named-like-handler-bug.spec.js

@@ -6,14 +6,14 @@ import { describe, it } from 'node:test';
 import { fileURLToPath } from 'node:url';
 import { ImportFromFolderNameError, packLambda } from './packLambda.js';
 const tmpDir = os.tmpdir();
-void describe('packLambda()', () => {
+void describe('packLambda()', ()=>{
     // See https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/issues/93#issuecomment-2042201321
-    void it('should fail if it imports from a folder on the same level that has the same name as the handler module', async () => assert.rejects(async () => packLambda({
-        sourceFilePath: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'module-folder-named-like-handler-bug', 'same-level', 'acme.ts'),
-        zipFilePath: path.join(await fs.mkdtemp(`${tmpDir}${path.sep}`), 'acme.zip'),
-    }), ImportFromFolderNameError));
-    void it('should not fail if it a folder with the same name is on a different level', async () => assert.doesNotReject(async () => packLambda({
-        sourceFilePath: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'module-folder-named-like-handler-bug', 'different-level', 'lambda', 'acme.ts'),
-        zipFilePath: path.join(await fs.mkdtemp(`${tmpDir}${path.sep}`), 'acme.zip'),
-    })));
+    void it('should fail if it imports from a folder on the same level that has the same name as the handler module', async ()=>assert.rejects(async ()=>packLambda({
+                sourceFilePath: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'module-folder-named-like-handler-bug', 'same-level', 'acme.ts'),
+                zipFilePath: path.join(await fs.mkdtemp(`${tmpDir}${path.sep}`), 'acme.zip')
+            }), ImportFromFolderNameError));
+    void it('should not fail if it a folder with the same name is on a different level', async ()=>assert.doesNotReject(async ()=>packLambda({
+                sourceFilePath: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'module-folder-named-like-handler-bug', 'different-level', 'lambda', 'acme.ts'),
+                zipFilePath: path.join(await fs.mkdtemp(`${tmpDir}${path.sep}`), 'acme.zip')
+            })));
 });

package/dist/src/packLambda.js

@@ -7,30 +7,33 @@ import yazl from 'yazl';
 import { checkSumOfFiles } from './checksumOfFiles.js';
 import { commonParent } from './commonParent.js';
 import { findDependencies } from './findDependencies.js';
-const removeCommonAncestor = (parentDir) => (filePath) => {
-    const p = parse(filePath);
-    const jsFileName = [
-        p.dir.replace(parentDir.slice(0, parentDir.length - 1), ''),
-        `${p.name}.js`,
-    ]
-        .join('/')
-        // Replace leading slash
+import { updateImports } from './updateImports.js';
+const removeCommonAncestor = (parentDir)=>(filePath)=>{
+        const p = parse(filePath);
+        const jsFileName = [
+            p.dir.replace(parentDir.slice(0, parentDir.length - 1), ''),
+            `${p.name}.js`
+        ].join('/')// Replace leading slash
         .replace(/^\//, '');
-    return jsFileName;
-};
+        return jsFileName;
+    };
 /**
  * In the bundle we only include code that's not in the layer.
- */
-export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath, debug, progress, }) => {
-    const { dependencies: deps, importsSubpathPatterns, packages, } = findDependencies({
+ */ export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath, debug, progress })=>{
+    const { dependencies: deps, importsSubpathPatterns, packages } = findDependencies({
         sourceFilePath,
-        tsConfigFilePath,
+        tsConfigFilePath
     });
-    debug?.(`${sourceFilePath}: dependencies`, [...packages].join(', '));
-    Object.entries(importsSubpathPatterns).forEach(([k, v]) => {
+    debug?.(`${sourceFilePath}: dependencies`, [
+        ...packages
+    ].join(', '));
+    Object.entries(importsSubpathPatterns).forEach(([k, v])=>{
         debug?.(`${sourceFilePath}:importsSubpathPattern`, `${k} -> ${v}`);
     });
-    const lambdaFiles = [sourceFilePath, ...deps];
+    const lambdaFiles = [
+        sourceFilePath,
+        ...deps
+    ];
     const zipfile = new yazl.ZipFile();
     const stripCommon = removeCommonAncestor(commonParent(lambdaFiles));
     const handler = stripCommon(sourceFilePath);
@@ -38,21 +41,21 @@ export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath
     const handlerInfo = path.parse(handler);
     const handlerName = handlerInfo.name;
     const handlerDir = handlerInfo.dir;
-    const handlerDepsFromSameDirectory = deps
-        .map(stripCommon)
-        .filter((d) => handlerDir === '' ? true : d.startsWith(`${handlerDir}${path.sep}`));
-    const handlerDepsFolderNames = new Set(handlerDepsFromSameDirectory.map((s) => s.split('/')[0]));
+    const handlerDepsFromSameDirectory = deps.map(stripCommon).filter((d)=>handlerDir === '' ? true : d.startsWith(`${handlerDir}${path.sep}`));
+    const handlerDepsFolderNames = new Set(handlerDepsFromSameDirectory.map((s)=>s.split('/')[0]));
     if (handlerDepsFolderNames.has(handlerName)) {
         throw new ImportFromFolderNameError(handlerName);
     }
     // Compile files
-    for (const file of lambdaFiles) {
-        const compiled = (await swc.transformFile(file, {
+    for (const file of lambdaFiles){
+        let compiled = (await swc.transformFile(file, {
             jsc: {
-                target: 'es2022',
-            },
+                target: 'es2022'
+            }
         })).code;
         debug?.(`compiled`, compiled);
+        compiled = updateImports(compiled);
+        debug?.(`converted imports`, compiled);
         const jsFileName = stripCommon(file);
         zipfile.addBuffer(Buffer.from(compiled, 'utf-8'), jsFileName);
         progress?.(`added`, jsFileName);
@@ -60,34 +63,40 @@ export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath
     const hash = await checkSumOfFiles([
         ...lambdaFiles,
         // Include this script, so artefact is updated if the way it's built is changed
-        fileURLToPath(import.meta.url),
+        fileURLToPath(import.meta.url)
     ]);
     // Mark it as ES module
     zipfile.addBuffer(Buffer.from(JSON.stringify({
         type: 'module',
-        imports: importsSubpathPatterns,
-        dependencies: Object.fromEntries([...packages.values()]
-            .sort((a, b) => a.localeCompare(b))
-            .map((pkg) => [pkg, '*'])),
-    }), 'utf-8'), 'package.json');
+        imports: Object.fromEntries(Object.entries(importsSubpathPatterns).map(([k, v])=>[
+                k,
+                v.replace(/\.ts$/, '.js')
+            ])),
+        dependencies: Object.fromEntries([
+            ...packages.values()
+        ].sort((a, b)=>a.localeCompare(b)).map((pkg)=>[
+                pkg,
+                '*'
+            ]))
+    }, null, 2), 'utf-8'), 'package.json');
     progress?.(`added`, 'package.json');
-    await new Promise((resolve) => {
-        zipfile.outputStream
-            .pipe(createWriteStream(zipFilePath))
-            .on('close', () => {
+    await new Promise((resolve)=>{
+        zipfile.outputStream.pipe(createWriteStream(zipFilePath)).on('close', ()=>{
             resolve();
         });
         zipfile.end();
     });
     progress?.(`written`, zipFilePath);
-    return { handler: stripCommon(sourceFilePath), hash };
+    return {
+        handler: stripCommon(sourceFilePath),
+        hash
+    };
 };
 /**
  * @see https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/issues/93#issuecomment-2042201321
- */
-export class ImportFromFolderNameError extends Error {
+ */ export class ImportFromFolderNameError extends Error {
     folderName;
-    constructor(folderName) {
+    constructor(folderName){
         super(`Import from folder with same name as handler ("${folderName}") not allowed!`);
         this.name = 'ImportFromFolderNameError';
         this.folderName = folderName;

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

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

package/dist/src/packLambda.spec.js

@@ -0,0 +1,28 @@
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path, { dirname } from 'node:path';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { packLambda } from './packLambda.js';
+import { getFileFromZip } from './test/getFileFromZip.js';
+const tmpDir = os.tmpdir();
+await describe('packLambda()', async ()=>{
+    await it('should convert .ts imports to .js', async ()=>{
+        const zipFilePath = path.join(await fs.mkdtemp(`${tmpDir}${path.sep}`), 'resolve-paths.zip');
+        await packLambda({
+            sourceFilePath: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'resolve-paths', 'lambda.ts'),
+            tsConfigFilePath: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'resolve-paths', 'tsconfig.json'),
+            zipFilePath
+        });
+        const handler = await getFileFromZip(zipFilePath, 'lambda.js');
+        assert.equal(handler.includes(`import { foo2 } from '#foo/2.js'`), true, 'The import should be converted to .js');
+        await assert.doesNotReject(getFileFromZip(zipFilePath, 'foo/2.js'), 'The ZIP file should contain the imported file');
+        const pJson = JSON.parse(await getFileFromZip(zipFilePath, 'package.json'));
+        assert.equal(pJson.type, 'module', 'The package.json should contain "type": "module"');
+        assert.deepEqual(pJson.imports, {
+            '#foo': './foo/index.js',
+            '#foo/*': './foo/*'
+        }, 'The package.json should contain the imports');
+    });
+});

package/dist/src/packLambdaFromPath.d.ts

@@ -1,4 +1,4 @@
-import { type PackedLambda } from './packLambda.js';
+import { type PackedLambda } from './packLambda.ts';
 export declare const packLambdaFromPath: ({ id, sourceFilePath, handlerFunction: handlerFunctionArg, baseDir: baseDirArg, distDir: distDirArg, tsConfigFilePath, debug, progress, }: {
     id: string;
     sourceFilePath: string;

package/dist/src/packLambdaFromPath.js

@@ -1,17 +1,16 @@
 import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { packLambda } from './packLambda.js';
-export const packLambdaFromPath = async ({ id, sourceFilePath, handlerFunction: handlerFunctionArg, baseDir: baseDirArg, distDir: distDirArg, tsConfigFilePath, debug, progress, }) => {
+export const packLambdaFromPath = async ({ id, sourceFilePath, handlerFunction: handlerFunctionArg, baseDir: baseDirArg, distDir: distDirArg, tsConfigFilePath, debug, progress })=>{
     const distDir = distDirArg ?? path.join(process.cwd(), 'dist', 'lambdas');
     const baseDir = baseDirArg ?? process.cwd();
     const handlerFunction = handlerFunctionArg ?? 'handler';
     try {
         await mkdir(distDir, {
-            recursive: true,
+            recursive: true
         });
-    }
-    catch {
-        // Directory exists
+    } catch  {
+    // Directory exists
     }
     const zipFile = path.join(distDir, `${id}.zip`);
     const { handler, hash } = await packLambda({
@@ -19,12 +18,12 @@ export const packLambdaFromPath = async ({ id, sourceFilePath, handlerFunction:
         zipFilePath: zipFile,
         tsConfigFilePath,
         debug,
-        progress,
+        progress
     });
     return {
         id,
         zipFilePath: zipFile,
         handler: handler.replace('.js', `.${handlerFunction}`),
-        hash,
+        hash
     };
 };

package/dist/src/packLayer.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { ZipFile } from 'yazl';
 import { checkSumOfFiles, checkSumOfStrings } from './checksumOfFiles.js';
-export const packLayer = async ({ id, dependencies, baseDir, distDir, installCommand, }) => {
+export const packLayer = async ({ id, dependencies, baseDir, distDir, installCommand })=>{
     const base = baseDir ?? process.cwd();
     const dist = distDir ?? path.join(base, 'dist', 'layers');
     const packageJsonFile = path.join(base, 'package.json');
@@ -15,28 +15,30 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
     const layerDir = path.join(dist, id);
     const nodejsDir = path.join(layerDir, 'nodejs');
     try {
-        await rm(layerDir, { recursive: true });
-    }
-    catch {
-        // Folder does not exist.
+        await rm(layerDir, {
+            recursive: true
+        });
+    } catch  {
+    // Folder does not exist.
     }
-    await mkdir(nodejsDir, { recursive: true });
-    const depsToBeInstalled = dependencies.reduce((resolved, dep) => {
+    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}!`);
+        if (resolvedDependency === undefined) throw new Error(`Could not resolve dependency "${dep}" in ${packageJsonFile}!`);
         return {
             ...resolved,
-            [dep]: resolvedDependency,
+            [dep]: resolvedDependency
         };
     }, {});
     const checkSumFiles = [
         // Include this script, so artefact is updated if the way it's built is changed
-        fileURLToPath(import.meta.url),
+        fileURLToPath(import.meta.url)
     ];
     const packageJSON = path.join(nodejsDir, 'package.json');
     await writeFile(packageJSON, JSON.stringify({
-        dependencies: depsToBeInstalled,
+        dependencies: depsToBeInstalled
     }), 'utf-8');
     checkSumFiles.push(packageJSON);
     let hasLockFile = true;
@@ -46,26 +48,25 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
         const packageLock = path.join(nodejsDir, 'package-lock.json');
         await copyFile(packageLockJsonFile, packageLock);
         checkSumFiles.push(packageLock);
-    }
-    catch {
+    } catch  {
         hasLockFile = false;
-        // pass
+    // pass
     }
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve, reject)=>{
         const [cmd, ...args] = installCommand?.({
             packageFilePath: packageJSON,
-            packageLockFilePath: packageLockJsonFile,
+            packageLockFilePath: packageLockJsonFile
         }) ?? [
             'npm',
             hasLockFile ? 'ci' : 'i',
             '--ignore-scripts',
             '--only=prod',
-            '--no-audit',
+            '--no-audit'
         ];
         const p = spawn(cmd, args, {
-            cwd: nodejsDir,
+            cwd: nodejsDir
         });
-        p.on('close', (code) => {
+        p.on('close', (code)=>{
             if (code !== 0) {
                 const msg = `${cmd} ${args.join(' ')} in ${nodejsDir} exited with code ${code}.`;
                 return reject(new Error(msg));
@@ -75,17 +76,15 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
     });
     const filesToAdd = await glob(`**`, {
         cwd: layerDir,
-        nodir: true,
+        nodir: true
     });
     const zipfile = new ZipFile();
-    filesToAdd.forEach((f) => {
+    filesToAdd.forEach((f)=>{
         zipfile.addFile(path.join(layerDir, f), f);
     });
-    const zipFileName = await new Promise((resolve) => {
+    const zipFileName = await new Promise((resolve)=>{
         const zipFileName = path.join(dist, `${id}.zip`);
-        zipfile.outputStream
-            .pipe(createWriteStream(zipFileName))
-            .on('close', () => {
+        zipfile.outputStream.pipe(createWriteStream(zipFileName)).on('close', ()=>{
             resolve(zipFileName);
         });
         zipfile.end();
@@ -94,7 +93,7 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
         layerZipFilePath: zipFileName,
         hash: checkSumOfStrings([
             JSON.stringify(dependencies),
-            await checkSumOfFiles(checkSumFiles),
-        ]),
+            await checkSumOfFiles(checkSumFiles)
+        ])
     };
 };

package/dist/src/test/getFileFromZip.d.ts

@@ -0,0 +1 @@
+export declare const getFileFromZip: (zipFilePath: string, filename: string) => Promise<string>;

package/dist/src/test/getFileFromZip.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+import unzip from 'unzip-stream';
+export const getFileFromZip = async (zipFilePath, filename)=>{
+    let found = false;
+    let content = '';
+    await new Promise((resolve, reject)=>{
+        fs.createReadStream(zipFilePath).pipe(unzip.Parse()).on('entry', (entry)=>{
+            if (entry.path === filename) {
+                found = true;
+                entry.on('data', (data)=>content += data);
+            } else {
+                entry.autodrain();
+            }
+        }).on('error', reject).on('end', resolve);
+    });
+    if (!found) {
+        throw new Error(`File not found in zip: ${filename}`);
+    }
+    return content;
+};

package/dist/src/test-data/module-folder-named-like-handler-bug/different-level/acme/lib.js

@@ -0,0 +1 @@
+export const hello = ()=>'Hello World!';

package/dist/src/test-data/module-folder-named-like-handler-bug/different-level/lambda/acme.js

@@ -0,0 +1,2 @@
+import { hello } from '../acme/lib.js';
+export const handler = ()=>hello();

package/dist/src/test-data/module-folder-named-like-handler-bug/same-level/acme/lib.js

@@ -0,0 +1 @@
+export const hello = ()=>'Hello World!';

package/dist/src/test-data/module-folder-named-like-handler-bug/same-level/acme.js

@@ -0,0 +1,2 @@
+import { hello } from './acme/lib.js';
+export const handler = ()=>hello();

package/dist/src/test-data/resolve-paths/foo/1.js

@@ -1 +1 @@
-export const foo = () => 42;
+export const foo = ()=>42;

package/dist/src/test-data/resolve-paths/foo/2.js

@@ -1 +1 @@
-export const foo2 = () => 17;
+export const foo2 = ()=>17;

package/dist/src/test-data/resolve-paths/lambda.js

@@ -0,0 +1,4 @@
+import { foo } from '#foo';
+import { foo2 } from '#foo/2.js';
+export const handler = ()=>foo() + foo2() // 42 + 17
+;

package/dist/src/updateImports.d.ts

@@ -0,0 +1 @@
+export declare const updateImports: (source: string) => string;

package/dist/src/updateImports.js

@@ -0,0 +1 @@
+export const updateImports = (source)=>source.replace(/from ['"](.+?)\.ts['"]/g, "from '$1.js'");

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

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

package/dist/src/updateImports.spec.js

@@ -0,0 +1,10 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { updateImports } from './updateImports.js';
+void describe('updateImports', ()=>{
+    void it('replaces .ts with .js in relative imports', ()=>{
+        const input = `import { foo } from './bar.js';`;
+        const expected = `import { foo } from './bar.js';`;
+        assert.equal(updateImports(input), expected);
+    });
+});

package/dist/src/util.d.ts

@@ -1,4 +1,4 @@
-export * from './checksumOfFiles.js';
-export * from './commonParent.js';
-export * from './findDependencies.js';
-export * from './isTest.js';
+export * from './checksumOfFiles.ts';
+export * from './commonParent.ts';
+export * from './findDependencies.ts';
+export * from './isTest.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bifravst/aws-cdk-lambda-helpers",
-  "version": "2.3.10",
+  "version": "3.0.1",
   "description": "Helper functions which simplify working with TypeScript lambdas for AWS CDK.",
   "exports": {
     ".": {
@@ -30,9 +30,10 @@
   },
   "type": "module",
   "scripts": {
-    "test": "tsx --no-warnings --test ./src/*.spec.ts",
+    "test": "node --experimental-strip-types --no-warnings --test ./src/*.spec.ts",
+    "test:e2e": "node --experimental-strip-types --test e2e.spec.ts",
     "prepare": "husky",
-    "prepublishOnly": "npx tsc --noEmit false --outDir ./dist -d"
+    "prepublishOnly": "node --experimental-strip-types npm-compile.ts && npx tsc -P tsconfig.npm.json --outDir ./dist/src"
   },
   "repository": {
     "type": "git",
@@ -58,15 +59,17 @@
     "@bifravst/from-env": "3.0.2",
     "@bifravst/prettier-config": "1.1.4",
     "@commitlint/config-conventional": "19.6.0",
+    "@swc/cli": "0.5.2",
     "@types/aws-lambda": "8.10.146",
     "@types/node": "22.10.2",
+    "@types/unzip-stream": "0.3.4",
     "@types/yazl": "2.4.5",
     "cdk": "2.173.4",
     "commitlint": "19.6.1",
     "husky": "9.1.7",
     "id128": "1.6.6",
     "lint-staged": "15.3.0",
-    "tsx": "4.19.2"
+    "unzip-stream": "0.3.4"
   },
   "lint-staged": {
     "*.ts": [
@@ -78,7 +81,7 @@
     ]
   },
   "engines": {
-    "node": ">=22",
+    "node": ">=22.7.0",
     "npm": ">=10"
   },
   "release": {

package/dist/src/test-data/resolve-paths/foo/1.d.ts

@@ -1 +0,0 @@
-export declare const foo: () => number;

package/dist/src/test-data/resolve-paths/foo/2.d.ts

@@ -1 +0,0 @@
-export declare const foo2: () => number;

package/dist/src/test-data/resolve-paths/foo/index.d.ts

@@ -1 +0,0 @@
-export { foo } from './1.js';