@bifravst/aws-cdk-lambda-helpers 2.2.0 → 2.2.2

package/dist/src/findDependencies.js

@@ -9,9 +9,13 @@ export const findDependencies = (args) => {
     const visited = args.visited ?? [];
     const dependencies = args.imports ?? [];
     const packages = args.packages ?? new Set();
-    let importsSubpathPatterns = args.importsSubpathPatterns ?? {};
+    const importsSubpathPatterns = args.importsSubpathPatterns ?? {};
     if (visited.includes(sourceFilePath))
-        return { dependencies, importsSubpathPatterns, packages };
+        return {
+            dependencies,
+            importsSubpathPatterns,
+            packages,
+        };
     const tsConfigFilePath = args.tsConfigFilePath;
     const tsConfig = tsConfigFilePath !== undefined
         ? JSON.parse(readFileSync(tsConfigFilePath, 'utf-8').toString())
@@ -23,14 +27,13 @@ export const findDependencies = (args) => {
             node.kind !== ts.SyntaxKind.ExportDeclaration)
             return;
         const moduleSpecifier = node.moduleSpecifier.text;
-        const { resolvedPath: file, importsSubpathPatterns: updatedImportsSubpathPatterns, } = resolve({
+        const { resolvedPath: file } = resolve({
             moduleSpecifier,
             sourceFilePath,
             tsConfigFilePath,
             tsConfig,
             importsSubpathPatterns,
         });
-        importsSubpathPatterns = updatedImportsSubpathPatterns;
         try {
             const s = statSync(file);
             if (!s.isDirectory())
@@ -54,7 +57,25 @@ export const findDependencies = (args) => {
             packages,
         });
     }
-    return { dependencies, 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-crypto/'))
+            .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('.'))
@@ -67,7 +88,6 @@ const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig,
                 // 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) {
@@ -78,16 +98,13 @@ const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig,
             // 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'),
+                ].join('');
                 return {
                     resolvedPath: fullResolvedPath,
-                    importsSubpathPatterns: {
-                        ...importsSubpathPatterns,
-                        [key]: [
-                            tsConfig.compilerOptions.baseUrl,
-                            path.sep,
-                            resolvedPath.replace(/\.ts$/, '.js'),
-                        ].join(''),
-                    },
                 };
             }
             // Wildcard match
@@ -97,24 +114,20 @@ const resolve = ({ moduleSpecifier, sourceFilePath, tsConfigFilePath, tsConfig,
             const maybeMatch = rx.exec(moduleSpecifier);
             if (maybeMatch?.groups?.wildcard === undefined)
                 continue;
+            importsSubpathPatterns[key] = [
+                tsConfig.compilerOptions.baseUrl,
+                path.sep,
+                resolvedPath.replace(/\.ts$/, '.js'),
+            ].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'),
-                importsSubpathPatterns: {
-                    ...importsSubpathPatterns,
-                    [key]: [
-                        tsConfig.compilerOptions.baseUrl,
-                        path.sep,
-                        resolvedPath.replace(/\.ts$/, '.js'),
-                    ].join(''),
-                },
             };
         }
     }
     return {
         resolvedPath: moduleSpecifier,
-        importsSubpathPatterns,
     };
 };

package/dist/src/findDependencies.spec.js

@@ -9,8 +9,11 @@ void describe('findDependencies()', () => {
         const { packages } = findDependencies({
             sourceFilePath: path.join(__dirname, '..', 'cdk', 'lambda.ts'),
         });
-        assert.equal(packages.has('aws-lambda'), true, "Should include the 'aws-lambda' package");
         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({

package/dist/src/packLambda.js

@@ -26,7 +26,10 @@ export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath
         sourceFilePath,
         tsConfigFilePath,
     });
-    debug?.(`dependencies`, [...packages].join(', '));
+    debug?.(`${sourceFilePath}: dependencies`, [...packages].join(', '));
+    Object.entries(importsSubpathPatterns).forEach(([k, v]) => {
+        debug?.(`${sourceFilePath}:importsSubpathPattern`, `${k} -> ${v}`);
+    });
     const lambdaFiles = [sourceFilePath, ...deps];
     const zipfile = new yazl.ZipFile();
     const stripCommon = removeCommonAncestor(commonParent(lambdaFiles));
@@ -63,7 +66,9 @@ export const packLambda = async ({ sourceFilePath, zipFilePath, tsConfigFilePath
     zipfile.addBuffer(Buffer.from(JSON.stringify({
         type: 'module',
         imports: importsSubpathPatterns,
-        dependencies: Object.fromEntries(packages.values().map((pkg) => [pkg, '*'])),
+        dependencies: Object.fromEntries([...packages.values()]
+            .sort((a, b) => a.localeCompare(b))
+            .map((pkg) => [pkg, '*'])),
     }), 'utf-8'), 'package.json');
     progress?.(`added`, 'package.json');
     await new Promise((resolve) => {

package/dist/src/packLambdaFromPath.d.ts

@@ -1,5 +1,5 @@
 import { type PackedLambda } from './packLambda.js';
-export declare const packLambdaFromPath: ({ id, sourceFilePath, handlerFunction: handlerFunctionArg, baseDir: baseDirArg, distDir: distDirArg, tsConfigFilePath, }: {
+export declare const packLambdaFromPath: ({ id, sourceFilePath, handlerFunction: handlerFunctionArg, baseDir: baseDirArg, distDir: distDirArg, tsConfigFilePath, debug, progress, }: {
     id: string;
     sourceFilePath: string;
     handlerFunction?: string;
@@ -15,4 +15,6 @@ export declare const packLambdaFromPath: ({ id, sourceFilePath, handlerFunction:
      * 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<PackedLambda>;

package/dist/src/packLambdaFromPath.js

@@ -1,7 +1,7 @@
 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, }) => {
+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';
@@ -18,6 +18,8 @@ export const packLambdaFromPath = async ({ id, sourceFilePath, handlerFunction:
         sourceFilePath: path.join(baseDir, sourceFilePath),
         zipFilePath: zipFile,
         tsConfigFilePath,
+        debug,
+        progress,
     });
     return {
         id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bifravst/aws-cdk-lambda-helpers",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Helper functions which simplify working with TypeScript lambdas for AWS CDK.",
   "exports": {
     ".": {
@@ -52,6 +52,7 @@
   "license": "BSD-3-Clause",
   "devDependencies": {
     "@aws-sdk/client-cloudformation": "3.693.0",
+    "@aws-sdk/client-dynamodb": "3.693.0",
     "@bifravst/cloudformation-helpers": "9.1.1",
     "@bifravst/eslint-config-typescript": "6.1.18",
     "@bifravst/from-env": "3.0.2",
@@ -108,6 +109,7 @@
   "prettier": "@bifravst/prettier-config",
   "dependencies": {
     "@swc/core": "1.9.2",
+    "fp-ts": "2.16.9",
     "glob": "11.0.0",
     "typescript": "5.6.3",
     "yazl": "3.3.0"