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

package/{npm → dist/src}/packLambda.js

@@ -8,32 +8,30 @@ import { checkSumOfFiles } from './checksumOfFiles.js';
 import { commonParent } from './commonParent.js';
 import { findDependencies } from './findDependencies.js';
 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
+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);
@@ -41,17 +39,19 @@ const removeCommonAncestor = (parentDir)=>(filePath)=>{
     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){
+    for (const file of lambdaFiles) {
         let compiled = (await swc.transformFile(file, {
             jsc: {
-                target: 'es2022'
-            }
+                target: 'es2022',
+            },
         })).code;
         debug?.(`compiled`, compiled);
         compiled = updateImports(compiled);
@@ -63,40 +63,37 @@ const removeCommonAncestor = (parentDir)=>(filePath)=>{
     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: 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,
-                '*'
-            ]))
+        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/{npm → dist/src}/packLambda.spec.js

@@ -7,22 +7,19 @@ 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 ()=>{
+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
+            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');
+        assert.deepEqual(pJson.imports, { '#foo': './foo/index.js', '#foo/*': './foo/*' }, 'The package.json should contain the imports');
     });
 });

package/{npm → dist/src}/packLambdaFromPath.js

@@ -2,16 +2,17 @@ import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { checkSumOfStrings } from './checksumOfFiles.js';
 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,15 +20,12 @@ export const packLambdaFromPath = async ({ id, sourceFilePath, handlerFunction:
         zipFilePath: zipFile,
         tsConfigFilePath,
         debug,
-        progress
+        progress,
     });
     return {
         id,
         zipFilePath: zipFile,
         handler: handler.replace('.js', `.${handlerFunction}`),
-        hash: checkSumOfStrings([
-            id,
-            hash
-        ])
+        hash: checkSumOfStrings([id, hash]),
     };
 };

package/{npm → 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');
@@ -16,30 +16,28 @@ 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 });
     }
-    await mkdir(nodejsDir, {
-        recursive: true
-    });
-    const depsToBeInstalled = dependencies.reduce((resolved, dep)=>{
+    catch {
+        // Folder does not exist.
+    }
+    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 hasNpmRcFile = true;
@@ -48,7 +46,8 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
         await stat(npmrcFile);
         await copyFile(npmrcFile, path.join(nodejsDir, '.npmrc'));
         checkSumFiles.push(npmrcFile);
-    } catch  {
+    }
+    catch {
         hasNpmRcFile = false;
     }
     let hasLockFile = true;
@@ -58,25 +57,26 @@ 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));
@@ -85,9 +85,7 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
         });
     });
     const zipfile = new ZipFile();
-    for await (const f of glob(`**`, {
-        cwd: layerDir
-    })){
+    for await (const f of glob(`**`, { cwd: layerDir })) {
         if ((await stat(path.join(layerDir, f))).isDirectory()) {
             continue;
         }
@@ -96,9 +94,11 @@ export const packLayer = async ({ id, dependencies, baseDir, distDir, installCom
     if (hasNpmRcFile) {
         zipfile.addFile(path.join(nodejsDir, '.npmrc'), 'nodejs/.npmrc');
     }
-    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();
@@ -107,7 +107,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/packLayer.spec.d.ts

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

package/{npm → dist/src}/packLayer.spec.js

@@ -7,16 +7,14 @@ import { fileURLToPath } from 'node:url';
 import { packLayer } from './packLayer.js';
 import { getFileFromZip } from './test/getFileFromZip.js';
 const tmpDir = os.tmpdir();
-await describe('packLayer()', async ()=>{
-    await it('should include a .npmrc file if present', async ()=>{
+await describe('packLayer()', async () => {
+    await it('should include a .npmrc file if present', async () => {
         const distDir = path.join(await fs.mkdtemp(`${tmpDir}${path.sep}`), 'jsr');
         const layer = await packLayer({
             baseDir: path.join(dirname(fileURLToPath(import.meta.url)), 'test-data', 'jsr'),
             distDir,
             id: 'jsr-layer',
-            dependencies: [
-                '@nrfcloud/wait-for-it'
-            ]
+            dependencies: ['@nrfcloud/wait-for-it'],
         });
         const npmrc = await getFileFromZip(layer.layerZipFilePath, 'nodejs/.npmrc');
         assert.equal(npmrc.includes(`@jsr:registry=https://npm.jsr.io`), true, 'The .npmrc file should contain the JSR registry');

package/dist/src/test/getFileFromZip.js

@@ -0,0 +1,25 @@
+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/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.ts';

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

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

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/{npm → dist/src}/updateImports.spec.js

@@ -1,9 +1,9 @@
 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';`;
+void describe('updateImports', () => {
+    void it('replaces .ts with .js in relative imports', () => {
+        const input = `import { foo } from './bar.ts';`;
         const expected = `import { foo } from './bar.js';`;
         assert.equal(updateImports(input), expected);
     });

package/dist/src/updateLambdaCode.js

@@ -0,0 +1,75 @@
+import { paginateListStackResources, } from '@aws-sdk/client-cloudformation';
+import { GetFunctionCommand, LastUpdateStatus, TagResourceCommand, UpdateFunctionCodeCommand, UpdateFunctionConfigurationCommand, } from '@aws-sdk/client-lambda';
+import assert from 'node:assert';
+import { readFile } from 'node:fs/promises';
+import pRetry from 'p-retry';
+const updateLambda = ({ lambda, packs, debug, forceUpdate, }) => async (lambdaResource) => {
+    const info = await lambda.send(new GetFunctionCommand({
+        FunctionName: lambdaResource.PhysicalResourceId,
+    }));
+    const packed = Object.values(packs).find((p) => p.id === info.Tags?.['packedLambda:id']);
+    if (packed === undefined) {
+        debug?.(`[${info.Tags?.['packedLambda:id']}]`, 'No pack found for lambda');
+        return;
+    }
+    debug?.(`[${packed.id}]`, 'found pack');
+    if ((forceUpdate ?? false) === false) {
+        if (packed.hash === info.Tags?.['packedLambda:hash']) {
+            debug?.(`[${packed.id}]`, 'No update needed');
+            return;
+        }
+    }
+    if (packed.hash !== info.Tags?.['packedLambda:hash']) {
+        debug?.(`[${packed.id}]`, 'Updating lambda');
+    }
+    const updateResult = await lambda.send(new UpdateFunctionCodeCommand({
+        FunctionName: lambdaResource.PhysicalResourceId,
+        ZipFile: new Uint8Array(await readFile(packed.zipFilePath)),
+    }));
+    debug?.(`[${packed.id}]`, 'RevisionId', updateResult.RevisionId);
+    debug?.(`[${packed.id}]`, 'CodeSha256', updateResult.CodeSha256);
+    await pRetry(async () => {
+        const updateStatus = (await lambda.send(new GetFunctionCommand({
+            FunctionName: lambdaResource.PhysicalResourceId,
+        }))).Configuration?.LastUpdateStatus;
+        assert.equal(updateStatus, LastUpdateStatus.Successful, `Lambda update should have succeeded, got ${updateStatus}`);
+    }, {
+        minTimeout: 1000,
+        maxTimeout: 1000,
+        retries: 10,
+    });
+    debug?.(`[${packed.id}]`, `updating config to trigger reload ...`);
+    await Promise.all([
+        lambda.send(new UpdateFunctionConfigurationCommand({
+            FunctionName: lambdaResource.PhysicalResourceId,
+            Environment: {
+                Variables: {
+                    ...info.Configuration?.Environment?.Variables,
+                    PACKED_LAMBDA_HASH: packed.hash,
+                },
+            },
+        })),
+        lambda.send(new TagResourceCommand({
+            Resource: info.Configuration.FunctionArn,
+            Tags: {
+                'packedLambda:hash': packed.hash,
+            },
+        })),
+    ]);
+};
+export const updateLambdaCode = ({ cf, lambda }) => async (stackName, packedLambdas, debug) => {
+    const u = updateLambda({
+        lambda,
+        packs: packedLambdas,
+        debug,
+    });
+    const p = [];
+    for await (const page of paginateListStackResources({ client: cf }, {
+        StackName: stackName,
+    })) {
+        p.push(...((page.StackResourceSummaries ?? [])
+            .filter((resource) => resource.ResourceType === 'AWS::Lambda::Function')
+            .map(u) ?? []));
+    }
+    await Promise.all(p);
+};

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@bifravst/aws-cdk-lambda-helpers",
-  "version": "4.0.96",
+  "version": "5.0.1",
   "description": "Helper functions which simplify working with TypeScript lambdas for AWS CDK.",
   "exports": {
     ".": {
       "import": {
-        "types": "./npm/lambda.d.ts",
-        "default": "./npm/lambda.js"
+        "types": "./dist/src/lambda.d.ts",
+        "default": "./dist/src/lambda.js"
       }
     },
     "./layer": {
       "import": {
-        "types": "./npm/layer.d.ts",
-        "default": "./npm/layer.js"
+        "types": "./dist/src/layer.d.ts",
+        "default": "./dist/src/layer.js"
       }
     },
     "./util": {
       "import": {
-        "types": "./npm/util.d.ts",
-        "default": "./npm/util.js"
+        "types": "./dist/src/util.d.ts",
+        "default": "./dist/src/util.js"
       }
     },
     "./cdk": {
       "import": {
-        "types": "./npm/cdk.d.ts",
-        "default": "./npm/cdk.js"
+        "types": "./dist/src/cdk.d.ts",
+        "default": "./dist/src/cdk.js"
       }
     }
   },
@@ -33,8 +33,8 @@
     "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",
-    "prepublishOnly": "node --experimental-strip-types .npm/npm-compile.ts && npx tsgo src/*.ts --emitDeclarationOnly --declaration --ignoreConfig --allowImportingTsExtensions --target esnext --module nodenext --moduleResolution nodenext --outDir ./npm && mv npm/src/* npm"
+    "prepare": "husky && case \"$npm_command\" in install|ci) check-node-version --package ;; esac",
+    "prepublishOnly": "npx tsc --noEmit false -d"
   },
   "repository": {
     "type": "git",
@@ -53,25 +53,27 @@
   "author": "Nordic Semiconductor ASA | nordicsemi.no",
   "license": "BSD-3-Clause",
   "devDependencies": {
-    "@aws-sdk/client-cloudformation": "3.981.0",
-    "@aws-sdk/client-dynamodb": "3.981.0",
-    "@bifravst/cloudformation-helpers": "9.1.1",
-    "@bifravst/eslint-config-typescript": "6.4.4",
-    "@bifravst/from-env": "3.0.2",
-    "@bifravst/prettier-config": "1.1.17",
-    "@commitlint/config-conventional": "20.3.1",
+    "@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": "25.6.0",
+    "@types/node": "26.2.0",
     "@types/unzip-stream": "0.3.4",
     "@types/yazl": "3.3.1",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "cdk": "2.1118.4",
-    "commitlint": "20.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": "16.4.0",
-    "unzip-stream": "0.3.4"
+    "lint-staged": "17.3.0",
+    "unzip-stream": "0.3.4",
+    "typescript": "npm:@typescript/typescript6@6.0.2"
   },
   "lint-staged": {
     "*.ts": [
@@ -83,8 +85,8 @@
     ]
   },
   "engines": {
-    "node": ">=24",
-    "npm": ">=11"
+    "node": ">=24.19.0 <25",
+    "npm": ">=12.0.2 <13"
   },
   "release": {
     "branches": [
@@ -108,22 +110,23 @@
     "access": "public"
   },
   "files": [
-    "npm",
+    "dist",
     "LICENSE",
     "README.md"
   ],
   "prettier": "@bifravst/prettier-config",
   "dependencies": {
-    "@swc/core": "1.15.43",
+    "@swc/core": "1.16.0",
     "fp-ts": "2.16.11",
-    "p-retry": "7.1.1",
-    "typescript": "5.9.3",
+    "p-retry": "8.0.0",
+    "typescript": "7.0.2",
     "yazl": "3.3.1"
   },
   "peerDependencies": {
-    "@aws-sdk/client-lambda": "^3.981.0",
-    "@bifravst/aws-ssm-settings-helpers": "^1.2.329",
-    "aws-cdk-lib": "^2.250.0",
-    "constructs": "^10.6.0"
+    "@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/npm/checkSumOfFiles.spec.js

@@ -1,15 +0,0 @@
-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'));
-});