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

package/dist/src/layer.d.ts

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

package/dist/src/layer.js

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

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

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

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

@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict';
+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 { ImportFromFolderNameError, packLambda } from './packLambda.js';
+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({
+        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.d.ts

@@ -0,0 +1,29 @@
+export type PackedLambda = {
+    id: string;
+    zipFilePath: string;
+    handler: string;
+    hash: string;
+};
+/**
+ * In the bundle we only include code that's not in the layer.
+ */
+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<{
+    handler: string;
+    hash: string;
+}>;
+/**
+ * @see https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/issues/93#issuecomment-2042201321
+ */
+export declare class ImportFromFolderNameError extends Error {
+    readonly folderName: string;
+    constructor(folderName: string);
+}

package/dist/src/packLambda.js

@@ -0,0 +1,101 @@
+import swc from '@swc/core';
+import { createWriteStream } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from 'path';
+import yazl from 'yazl';
+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
+        .replace(/^\//, '');
+    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({
+        sourceFilePath,
+        tsConfigFilePath,
+    });
+    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));
+    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;
+    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]));
+    if (handlerDepsFolderNames.has(handlerName)) {
+        throw new ImportFromFolderNameError(handlerName);
+    }
+    // Compile files
+    for (const file of lambdaFiles) {
+        let compiled = (await swc.transformFile(file, {
+            jsc: {
+                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);
+    }
+    const hash = await checkSumOfFiles([
+        ...lambdaFiles,
+        // Include this script, so artefact is updated if the way it's built is changed
+        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, '*'])),
+    }, null, 2), 'utf-8'), 'package.json');
+    progress?.(`added`, 'package.json');
+    await new Promise((resolve) => {
+        zipfile.outputStream
+            .pipe(createWriteStream(zipFilePath))
+            .on('close', () => {
+            resolve();
+        });
+        zipfile.end();
+    });
+    progress?.(`written`, zipFilePath);
+    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 {
+    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,25 @@
+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

@@ -0,0 +1,20 @@
+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;
+    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;
+    debug?: (label: string, info: string) => void;
+    progress?: (label: string, info: string) => void;
+}) => Promise<PackedLambda>;

package/dist/src/packLambdaFromPath.js

@@ -0,0 +1,31 @@
+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, }) => {
+    const distDir = distDirArg ?? path.join(process.cwd(), 'dist', 'lambdas');
+    const baseDir = baseDirArg ?? process.cwd();
+    const handlerFunction = handlerFunctionArg ?? 'handler';
+    try {
+        await mkdir(distDir, {
+            recursive: true,
+        });
+    }
+    catch {
+        // Directory exists
+    }
+    const zipFile = path.join(distDir, `${id}.zip`);
+    const { handler, hash } = await packLambda({
+        sourceFilePath: path.join(baseDir, sourceFilePath),
+        zipFilePath: zipFile,
+        tsConfigFilePath,
+        debug,
+        progress,
+    });
+    return {
+        id,
+        zipFilePath: zipFile,
+        handler: handler.replace('.js', `.${handlerFunction}`),
+        hash: checkSumOfStrings([id, hash]),
+    };
+};

package/dist/src/packLayer.d.ts

@@ -0,0 +1,23 @@
+export type PackedLayer = {
+    layerZipFilePath: string;
+    hash: string;
+};
+export declare const packLayer: ({ id, dependencies, baseDir, distDir, installCommand, }: {
+    id: string;
+    dependencies: string[];
+    /**
+     * @default process.cwd()
+     */
+    baseDir?: string;
+    /**
+     * @default ${baseDir}/dist/layers
+     */
+    distDir?: string;
+    /**
+     * Returns the command to run, the first element is the command (e.g. `npm`) and the rest are its arguments.
+     */
+    installCommand?: (args: {
+        packageFilePath: string;
+        packageLockFilePath: string;
+    }) => [string, ...Array<string>];
+}) => Promise<PackedLayer>;

package/dist/src/packLayer.js

@@ -0,0 +1,113 @@
+import { spawn } from 'child_process';
+import { createWriteStream } from 'fs';
+import { copyFile, mkdir, readFile, rm, stat, writeFile } from 'fs/promises';
+import { glob } from 'node:fs/promises';
+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, }) => {
+    const base = baseDir ?? process.cwd();
+    const dist = distDir ?? path.join(base, 'dist', 'layers');
+    const packageJsonFile = path.join(base, 'package.json');
+    const npmrcFile = path.join(base, '.npmrc');
+    const packageLockJsonFile = path.join(base, 'package-lock.json');
+    const { dependencies: deps, devDependencies: devDeps } = JSON.parse(await readFile(packageJsonFile, 'utf-8'));
+    const layerDir = path.join(dist, id);
+    const nodejsDir = path.join(layerDir, 'nodejs');
+    try {
+        await rm(layerDir, { recursive: true });
+    }
+    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}!`);
+        return {
+            ...resolved,
+            [dep]: resolvedDependency,
+        };
+    }, {});
+    const checkSumFiles = [
+        // Include this script, so artefact is updated if the way it's built is changed
+        fileURLToPath(import.meta.url),
+    ];
+    const packageJSON = path.join(nodejsDir, 'package.json');
+    await writeFile(packageJSON, JSON.stringify({
+        dependencies: depsToBeInstalled,
+    }), 'utf-8');
+    checkSumFiles.push(packageJSON);
+    let hasNpmRcFile = true;
+    try {
+        // .npmrc may not exist
+        await stat(npmrcFile);
+        await copyFile(npmrcFile, path.join(nodejsDir, '.npmrc'));
+        checkSumFiles.push(npmrcFile);
+    }
+    catch {
+        hasNpmRcFile = false;
+    }
+    let hasLockFile = true;
+    try {
+        // package-lock.json may not exist
+        await stat(packageLockJsonFile);
+        const packageLock = path.join(nodejsDir, 'package-lock.json');
+        await copyFile(packageLockJsonFile, packageLock);
+        checkSumFiles.push(packageLock);
+    }
+    catch {
+        hasLockFile = false;
+        // pass
+    }
+    await new Promise((resolve, reject) => {
+        const [cmd, ...args] = installCommand?.({
+            packageFilePath: packageJSON,
+            packageLockFilePath: packageLockJsonFile,
+        }) ?? [
+            'npm',
+            hasLockFile ? 'ci' : 'i',
+            '--ignore-scripts',
+            '--only=prod',
+            '--no-audit',
+        ];
+        const p = spawn(cmd, args, {
+            cwd: nodejsDir,
+        });
+        p.on('close', (code) => {
+            if (code !== 0) {
+                const msg = `${cmd} ${args.join(' ')} in ${nodejsDir} exited with code ${code}.`;
+                return reject(new Error(msg));
+            }
+            return resolve();
+        });
+    });
+    const zipfile = new ZipFile();
+    for await (const f of glob(`**`, { cwd: layerDir })) {
+        if ((await stat(path.join(layerDir, f))).isDirectory()) {
+            continue;
+        }
+        zipfile.addFile(path.join(layerDir, f), f);
+    }
+    if (hasNpmRcFile) {
+        zipfile.addFile(path.join(nodejsDir, '.npmrc'), 'nodejs/.npmrc');
+    }
+    const zipFileName = await new Promise((resolve) => {
+        const zipFileName = path.join(dist, `${id}.zip`);
+        zipfile.outputStream
+            .pipe(createWriteStream(zipFileName))
+            .on('close', () => {
+            resolve(zipFileName);
+        });
+        zipfile.end();
+    });
+    return {
+        layerZipFilePath: zipFileName,
+        hash: checkSumOfStrings([
+            JSON.stringify(dependencies),
+            await checkSumOfFiles(checkSumFiles),
+        ]),
+    };
+};

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

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

package/dist/src/packLayer.spec.js

@@ -0,0 +1,22 @@
+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 { 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 () => {
+        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'],
+        });
+        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.d.ts

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

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.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.ts';`;
+        const expected = `import { foo } from './bar.js';`;
+        assert.equal(updateImports(input), expected);
+    });
+});

package/dist/src/updateLambdaCode.d.ts

@@ -0,0 +1,7 @@
+import { type CloudFormationClient } from '@aws-sdk/client-cloudformation';
+import { type LambdaClient } from '@aws-sdk/client-lambda';
+import type { PackedLambda } from './packLambda.ts';
+export declare const updateLambdaCode: ({ cf, lambda }: {
+    cf: CloudFormationClient;
+    lambda: LambdaClient;
+}) => (stackName: string, packedLambdas: Record<string, PackedLambda>, debug?: (...args: Array<any>) => void) => Promise<void>;

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/dist/src/util.d.ts

@@ -0,0 +1,5 @@
+export * from './checksumOfFiles.ts';
+export * from './commonParent.ts';
+export * from './findDependencies.ts';
+export * from './isTest.ts';
+export * from './updateLambdaCode.ts';

package/dist/src/util.js

@@ -0,0 +1,5 @@
+export * from './checksumOfFiles.js';
+export * from './commonParent.js';
+export * from './findDependencies.js';
+export * from './isTest.js';
+export * from './updateLambdaCode.js';

package/package.json

@@ -1,29 +1,29 @@
 {
   "name": "@bifravst/aws-cdk-lambda-helpers",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Helper functions which simplify working with TypeScript lambdas for AWS CDK.",
   "exports": {
     ".": {
       "import": {
-        "types": "./lambda.ts",
+        "types": "./dist/src/lambda.d.ts",
         "default": "./dist/src/lambda.js"
       }
     },
     "./layer": {
       "import": {
-        "types": "./layer.ts",
+        "types": "./dist/src/layer.d.ts",
         "default": "./dist/src/layer.js"
       }
     },
     "./util": {
       "import": {
-        "types": "./util.ts",
+        "types": "./dist/src/util.d.ts",
         "default": "./dist/src/util.js"
       }
     },
     "./cdk": {
       "import": {
-        "types": "./cdk.ts",
+        "types": "./dist/src/cdk.d.ts",
         "default": "./dist/src/cdk.js"
       }
     }
@@ -110,7 +110,7 @@
     "access": "public"
   },
   "files": [
-    "npm",
+    "dist",
     "LICENSE",
     "README.md"
   ],