@bifravst/aws-cdk-lambda-helpers 1.10.59 → 2.0.1

package/dist/src/LambdaSource.d.ts

@@ -3,5 +3,5 @@ import { Construct } from 'constructs';
 import type { PackedLambda } from './packLambda.js';
 export declare class LambdaSource extends Construct {
     readonly code: Lambda.S3Code;
-    constructor(parent: Construct, packedLambda: Pick<PackedLambda, 'zipFile' | 'id' | 'hash'>);
+    constructor(parent: Construct, packedLambda: Pick<PackedLambda, 'zipFilePath' | 'id' | 'hash'>);
 }

package/dist/src/LambdaSource.js

@@ -5,7 +5,7 @@ export class LambdaSource extends Construct {
     constructor(parent, packedLambda) {
         super(parent, `${packedLambda.id}Source`);
         const asset = new S3Assets.Asset(this, 'asset', {
-            path: packedLambda.zipFile,
+            path: packedLambda.zipFilePath,
             assetHash: packedLambda.hash,
             assetHashType: AssetHashType.CUSTOM,
         });

package/dist/src/checksumOfFiles.js

@@ -14,12 +14,12 @@ export const checkSumOfStrings = (strings) => {
     return hash.digest('hex');
 };
 const hashCache = {};
-const hashFile = async (file) => {
-    if (hashCache[file] === undefined) {
-        hashCache[file] = await new Promise((resolve) => {
+const hashFile = async (filePath) => {
+    if (hashCache[filePath] === undefined) {
+        hashCache[filePath] = await new Promise((resolve) => {
             const hash = crypto.createHash('sha1');
             hash.setEncoding('hex');
-            const fileStream = fs.createReadStream(file);
+            const fileStream = fs.createReadStream(filePath);
             fileStream.pipe(hash, { end: false });
             fileStream.on('end', () => {
                 hash.end();
@@ -28,7 +28,7 @@ const hashFile = async (file) => {
             });
         });
     }
-    return hashCache[file];
+    return hashCache[filePath];
 };
 /**
  * Computes the checksum for the given files

package/dist/src/findDependencies.d.ts

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

package/dist/src/findDependencies.js

@@ -4,25 +4,26 @@ 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))
+export const findDependencies = ({ sourceFilePath, tsConfigFilePath, imports: importsArg, visited: visitedArg, }) => {
+    const visited = visitedArg ?? [];
+    const imports = importsArg ?? [];
+    if (visited.includes(sourceFilePath))
         return imports;
-    const fileNode = ts.createSourceFile(sourceFile, readFileSync(sourceFile, 'utf-8').toString(), ts.ScriptTarget.ES2022, 
+    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)
             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;
+        const file = resolve({
+            moduleSpecifier,
+            sourceFilePath,
+            tsConfigFilePath,
+            tsConfig,
+        });
         try {
             const s = statSync(file);
             if (!s.isDirectory())
@@ -34,9 +35,49 @@ export const findDependencies = (sourceFile, imports = [], visited = []) => {
         }
     };
     ts.forEachChild(fileNode, parseChild);
-    visited.push(sourceFile);
+    visited.push(sourceFilePath);
     for (const file of imports) {
-        findDependencies(file, imports, visited);
+        findDependencies({
+            sourceFilePath: file,
+            imports,
+            visited,
+            tsConfigFilePath,
+        });
     }
     return imports;
 };
+const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig, }) => {
+    if (moduleSpecifier.startsWith('.'))
+        return (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 [resolvedPath] = value;
+            if (resolvedPath === undefined)
+                continue;
+            // Exact match
+            if (moduleSpecifier === key) {
+                return path.join(path.parse(tsConfigFilePath).dir, tsConfig.compilerOptions.baseUrl, resolvedPath);
+            }
+            // Wildcard match
+            if (!key.includes('*'))
+                continue;
+            const rx = new RegExp(`^${key.replace('*', '(?<wildcard>.*)')}`);
+            const maybeMatch = rx.exec(moduleSpecifier);
+            if (maybeMatch?.groups?.wildcard === undefined)
+                continue;
+            return (path
+                .resolve(path.parse(tsConfigFilePath).dir, tsConfig.compilerOptions.baseUrl, resolvedPath.replace('*', maybeMatch.groups.wildcard))
+                // Same as above, replace `.js` with `.ts`
+                .replace(/\.js$/, '.ts'));
+        }
+    }
+    return moduleSpecifier;
+};

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

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

package/dist/src/findDependencies.spec.js

@@ -0,0 +1,16 @@
+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 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', '2.ts')), true, 'Should include the module file');
+    });
+});

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

@@ -9,11 +9,11 @@ const tmpDir = os.tmpdir();
 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({
-        sourceFile: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'module-folder-named-like-handler-bug', 'same-level', 'acme.ts'),
-        zipFile: path.join(await fs.mkdtemp(`${tmpDir}${path.sep}`), 'acme.zip'),
+        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({
-        sourceFile: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'module-folder-named-like-handler-bug', 'different-level', 'lambda', 'acme.ts'),
-        zipFile: path.join(await fs.mkdtemp(`${tmpDir}${path.sep}`), 'acme.zip'),
+        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.d.ts

@@ -1,15 +1,19 @@
 export type PackedLambda = {
     id: string;
-    zipFile: string;
+    zipFilePath: 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;
+export declare const packLambda: ({ sourceFilePath, zipFilePath, tsConfigFilePath, debug, progress, }: {
+    sourceFilePath: string;
+    zipFilePath: string;
+    /**
+     * Pass the path to the tsconfig.json file if you want to use paths from the tsconfig.json file.
+     */
+    tsConfigFilePath?: string;
     debug?: (label: string, info: string) => void;
     progress?: (label: string, info: string) => void;
 }) => Promise<{

package/dist/src/packLambda.js

@@ -7,8 +7,8 @@ import yazl from 'yazl';
 import { checkSumOfFiles } from './checksumOfFiles.js';
 import { commonParent } from './commonParent.js';
 import { findDependencies } from './findDependencies.js';
-const removeCommonAncestor = (parentDir) => (file) => {
-    const p = parse(file);
+const removeCommonAncestor = (parentDir) => (filePath) => {
+    const p = parse(filePath);
     const jsFileName = [
         p.dir.replace(parentDir.slice(0, parentDir.length - 1), ''),
         `${p.name}.js`,
@@ -21,12 +21,15 @@ const removeCommonAncestor = (parentDir) => (file) => {
 /**
  * In the bundle we only include code that's not in the layer.
  */
-export const packLambda = async ({ sourceFile, zipFile, debug, progress, }) => {
-    const deps = findDependencies(sourceFile);
-    const lambdaFiles = [sourceFile, ...deps];
+export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath, debug, progress, }) => {
+    const deps = findDependencies({
+        sourceFilePath,
+        tsConfigFilePath,
+    });
+    const lambdaFiles = [sourceFilePath, ...deps];
     const zipfile = new yazl.ZipFile();
     const stripCommon = removeCommonAncestor(commonParent(lambdaFiles));
-    const handler = stripCommon(sourceFile);
+    const handler = stripCommon(sourceFilePath);
     // Make sure that the handler does not import from a folder with the same name in the folder
     const handlerInfo = path.parse(handler);
     const handlerName = handlerInfo.name;
@@ -61,13 +64,15 @@ export const packLambda = async ({ sourceFile, zipFile, debug, progress, }) => {
     }), 'utf-8'), 'package.json');
     progress?.(`added`, 'package.json');
     await new Promise((resolve) => {
-        zipfile.outputStream.pipe(createWriteStream(zipFile)).on('close', () => {
+        zipfile.outputStream
+            .pipe(createWriteStream(zipFilePath))
+            .on('close', () => {
             resolve();
         });
         zipfile.end();
     });
-    progress?.(`written`, zipFile);
-    return { handler: stripCommon(sourceFile), hash };
+    progress?.(`written`, zipFilePath);
+    return { handler: stripCommon(sourceFilePath), hash };
 };
 /**
  * @see https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/issues/93#issuecomment-2042201321

package/dist/src/packLambdaFromPath.d.ts

@@ -1,2 +1,18 @@
 import { type PackedLambda } from './packLambda.js';
-export declare const packLambdaFromPath: (id: string, sourceFile: string, handlerFunction?: string, baseDir?: string, distDir?: string) => Promise<PackedLambda>;
+export declare const packLambdaFromPath: ({ id, sourceFilePath, handlerFunction: handlerFunctionArg, baseDir: baseDirArg, distDir: distDirArg, tsConfigFilePath, }: {
+    id: string;
+    sourceFilePath: string;
+    handlerFunction?: string;
+    /**
+     * @default process.cwd()
+     */
+    baseDir?: string;
+    /**
+     * @default ${baseDir}/dist/lambdas
+     */
+    distDir?: string;
+    /**
+     * Pass the path to the tsconfig.json file if you want to use paths from the tsconfig.json file.
+     */
+    tsConfigFilePath?: string;
+}) => Promise<PackedLambda>;

package/dist/src/packLambdaFromPath.js

@@ -1,15 +1,10 @@
 import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { packLambda } from './packLambda.js';
-export const packLambdaFromPath = async (id, sourceFile, handlerFunction = 'handler', 
-/**
- * @default process.cwd()
- */
-baseDir = process.cwd(), 
-/**
- * @default ${baseDir}/dist/lambdas
- */
-distDir = path.join(process.cwd(), 'dist', 'lambdas')) => {
+export const packLambdaFromPath = async ({ id, sourceFilePath, handlerFunction: handlerFunctionArg, baseDir: baseDirArg, distDir: distDirArg, tsConfigFilePath, }) => {
+    const distDir = distDirArg ?? path.join(process.cwd(), 'dist', 'lambdas');
+    const baseDir = baseDirArg ?? process.cwd();
+    const handlerFunction = handlerFunctionArg ?? 'handler';
     try {
         await mkdir(distDir, {
             recursive: true,
@@ -20,12 +15,13 @@ distDir = path.join(process.cwd(), 'dist', 'lambdas')) => {
     }
     const zipFile = path.join(distDir, `${id}.zip`);
     const { handler, hash } = await packLambda({
-        sourceFile: path.join(baseDir, sourceFile),
-        zipFile,
+        sourceFilePath: path.join(baseDir, sourceFilePath),
+        zipFilePath: zipFile,
+        tsConfigFilePath,
     });
     return {
         id,
-        zipFile,
+        zipFilePath: zipFile,
         handler: handler.replace('.js', `.${handlerFunction}`),
         hash,
     };

package/dist/src/packLayer.d.ts

@@ -1,5 +1,5 @@
 export type PackedLayer = {
-    layerZipFile: string;
+    layerZipFilePath: string;
     hash: string;
 };
 export declare const packLayer: ({ id, dependencies, baseDir, distDir, installCommand, }: {
@@ -17,7 +17,7 @@ export declare const packLayer: ({ id, dependencies, baseDir, distDir, installCo
      * Returns the command to run, the first element is the command (e.g. `npm`) and the rest are its arguments.
      */
     installCommand?: (args: {
-        packageFile: string;
-        packageLockFile: string;
+        packageFilePath: string;
+        packageLockFilePath: string;
     }) => [string, ...Array<string>];
 }) => Promise<PackedLayer>;

package/dist/src/packLayer.js

@@ -53,8 +53,8 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
     }
     await new Promise((resolve, reject) => {
         const [cmd, ...args] = installCommand?.({
-            packageFile: packageJSON,
-            packageLockFile: packageLockJsonFile,
+            packageFilePath: packageJSON,
+            packageLockFilePath: packageLockJsonFile,
         }) ?? [
             'npm',
             hasLockFile ? 'ci' : 'i',
@@ -91,7 +91,7 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
         zipfile.end();
     });
     return {
-        layerZipFile: zipFileName,
+        layerZipFilePath: zipFileName,
         hash: checkSumOfStrings([
             JSON.stringify(dependencies),
             await checkSumOfFiles(checkSumFiles),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bifravst/aws-cdk-lambda-helpers",
-  "version": "1.10.59",
+  "version": "2.0.1",
   "description": "Helper functions which simplify working with TypeScript lambdas for AWS CDK.",
   "exports": {
     ".": {
@@ -110,7 +110,7 @@
     "@swc/core": "1.9.2",
     "glob": "11.0.0",
     "typescript": "5.6.3",
-    "yazl": "2.5.1"
+    "yazl": "3.3.0"
   },
   "peerDependencies": {
     "@bifravst/aws-ssm-settings-helpers": "^1.2.61",

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

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

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

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

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

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

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

@@ -1,2 +0,0 @@
-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.d.ts

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

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

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

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

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

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

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