@bifravst/aws-cdk-lambda-helpers 2.0.0 → 2.1.0

package/dist/src/findDependencies.d.ts

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

package/dist/src/findDependencies.js

@@ -4,30 +4,36 @@ import ts, {} from 'typescript';
 /**
  * Resolve project-level dependencies for the given file using TypeScript compiler API
  */
-export const findDependencies = ({ sourceFilePath, tsConfigFilePath, imports: importsArg, visited: visitedArg, }) => {
-    const visited = visitedArg ?? [];
-    const imports = importsArg ?? [];
+export const findDependencies = (args) => {
+    const sourceFilePath = args.sourceFilePath;
+    const visited = args.visited ?? [];
+    const dependencies = args.imports ?? [];
+    let importsSubpathPatterns = args.importsSubpathPatterns ?? {};
     if (visited.includes(sourceFilePath))
-        return imports;
+        return { dependencies, importsSubpathPatterns };
+    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)
+        if (node.kind !== ts.SyntaxKind.ImportDeclaration &&
+            node.kind !== ts.SyntaxKind.ExportDeclaration)
             return;
         const moduleSpecifier = node.moduleSpecifier.text;
-        const file = resolve({
+        const { resolvedPath: file, importsSubpathPatterns: updatedImportsSubpathPatterns, } = resolve({
             moduleSpecifier,
             sourceFilePath,
             tsConfigFilePath,
             tsConfig,
+            importsSubpathPatterns,
         });
+        importsSubpathPatterns = updatedImportsSubpathPatterns;
         try {
             const s = statSync(file);
             if (!s.isDirectory())
-                imports.push(file);
+                dependencies.push(file);
         }
         catch {
             // Module or file not found
@@ -36,26 +42,30 @@ export const findDependencies = ({ sourceFilePath, tsConfigFilePath, imports: im
     };
     ts.forEachChild(fileNode, parseChild);
     visited.push(sourceFilePath);
-    for (const file of imports) {
+    for (const file of dependencies) {
         findDependencies({
             sourceFilePath: file,
-            imports,
+            imports: dependencies,
             visited,
             tsConfigFilePath,
+            importsSubpathPatterns,
         });
     }
-    return imports;
+    return { dependencies, importsSubpathPatterns };
 };
-const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig, }) => {
+const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig, importsSubpathPatterns, }) => {
     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'));
+        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'),
+            importsSubpathPatterns,
+        };
     if (tsConfigFilePath !== undefined &&
         tsConfig?.compilerOptions?.paths !== undefined) {
         for (const [key, value] of Object.entries(tsConfig.compilerOptions.paths)) {
@@ -64,7 +74,18 @@ const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig,
                 continue;
             // Exact match
             if (moduleSpecifier === key) {
-                return path.join(path.parse(tsConfigFilePath).dir, tsConfig.compilerOptions.baseUrl, resolvedPath);
+                const fullResolvedPath = path.join(path.parse(tsConfigFilePath).dir, tsConfig.compilerOptions.baseUrl, resolvedPath);
+                return {
+                    resolvedPath: fullResolvedPath,
+                    importsSubpathPatterns: {
+                        ...importsSubpathPatterns,
+                        [key]: [
+                            tsConfig.compilerOptions.baseUrl,
+                            path.sep,
+                            resolvedPath.replace(/\.ts$/, '.js'),
+                        ].join(''),
+                    },
+                };
             }
             // Wildcard match
             if (!key.includes('*'))
@@ -73,11 +94,24 @@ const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig,
             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 {
+                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'),
+                importsSubpathPatterns: {
+                    ...importsSubpathPatterns,
+                    [key]: [
+                        tsConfig.compilerOptions.baseUrl,
+                        path.sep,
+                        resolvedPath.replace(/\.ts$/, '.js'),
+                    ].join(''),
+                },
+            };
         }
     }
-    return moduleSpecifier;
+    return {
+        resolvedPath: moduleSpecifier,
+        importsSubpathPatterns,
+    };
 };

package/dist/src/findDependencies.spec.js

@@ -6,11 +6,22 @@ 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({
+        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.js',
+            '#foo/*': './foo/*',
+        });
+    });
 });

package/dist/src/packLambda.js

@@ -22,7 +22,7 @@ const removeCommonAncestor = (parentDir) => (filePath) => {
  * In the bundle we only include code that's not in the layer.
  */
 export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath, debug, progress, }) => {
-    const deps = findDependencies({
+    const { dependencies: deps, importsSubpathPatterns } = findDependencies({
         sourceFilePath,
         tsConfigFilePath,
     });
@@ -61,6 +61,7 @@ export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath
     // Mark it as ES module
     zipfile.addBuffer(Buffer.from(JSON.stringify({
         type: 'module',
+        imports: importsSubpathPatterns,
     }), 'utf-8'), 'package.json');
     progress?.(`added`, 'package.json');
     await new Promise((resolve) => {

package/dist/src/packLambdaFromPath.d.ts

@@ -1,2 +1,18 @@
 import { type PackedLambda } from './packLambda.js';
-export declare const packLambdaFromPath: (id: string, sourceFilePath: 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, sourceFilePath, 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,
@@ -22,6 +17,7 @@ distDir = path.join(process.cwd(), 'dist', 'lambdas')) => {
     const { handler, hash } = await packLambda({
         sourceFilePath: path.join(baseDir, sourceFilePath),
         zipFilePath: zipFile,
+        tsConfigFilePath,
     });
     return {
         id,

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

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

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

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

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

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

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

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bifravst/aws-cdk-lambda-helpers",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Helper functions which simplify working with TypeScript lambdas for AWS CDK.",
   "exports": {
     ".": {
@@ -51,7 +51,7 @@
   "author": "Nordic Semiconductor ASA | nordicsemi.no",
   "license": "BSD-3-Clause",
   "devDependencies": {
-    "@aws-sdk/client-cloudformation": "3.691.0",
+    "@aws-sdk/client-cloudformation": "3.692.0",
     "@bifravst/cloudformation-helpers": "9.1.1",
     "@bifravst/eslint-config-typescript": "6.1.18",
     "@bifravst/from-env": "3.0.2",