@nrfcloud/lambda-helpers 1.0.28

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Nordic Semiconductor ASA | nordicsemi.no
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,34 @@
+# `@nrfcloud/lambda-helpers`
+
+<https://www.npmjs.com/package/@nrfcloud/lambda-helpers>
+
+Helper functions for AWS Lambda functions used in nRF Cloud.
+
+## Install with NPM
+
+```bash
+npm i (--save-prod|--save-dev) @nrfcloud/lambda-helpers
+```
+
+## Usage
+
+```typescript
+import { MetricUnit } from "@aws-lambda-powertools/metrics";
+import { logMetrics } from "@aws-lambda-powertools/metrics/middleware";
+import middy from "@middy/core";
+import { metricsForComponent } from "@nrfcloud/lambda-helpers";
+
+const { track, metrics } = metricsForComponent("my-function", "my-service");
+
+export const handler = middy()
+  .use(logMetrics(metrics))
+  .handler(async () => {
+    track("some:metric", MetricUnit.Count, 1);
+  });
+```
+
+## TypeScript 6 and 7
+
+This repo
+[runs TypeScript 6 and 7 side by side](https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/#running-side-by-side-with-typescript-6.0),
+[so that eslint works](https://github.com/typescript-eslint/typescript-eslint/issues/10940#issuecomment-4922812181).

package/npm/aProblem.d.ts

@@ -0,0 +1,4 @@
+import { type ProblemDetail } from '@nrfcloud/problem-detail';
+import type { Static } from '@sinclair/typebox';
+import type { APIGatewayProxyStructuredResultV2 } from 'aws-lambda';
+export declare const aProblem: (problem: Omit<Static<typeof ProblemDetail>, '@context'>, cacheForSeconds?: number) => APIGatewayProxyStructuredResultV2;

package/npm/aProblem.js

@@ -0,0 +1,12 @@
+import { Context as ProblemDetailContext } from '@nrfcloud/problem-detail';
+export const aProblem = (problem, cacheForSeconds = 0)=>({
+        statusCode: problem.status,
+        headers: {
+            'content-type': 'application/problem+json',
+            'Cache-Control': cacheForSeconds > 0 ? `public, max-age=${cacheForSeconds}` : 'no-store'
+        },
+        body: JSON.stringify({
+            '@context': ProblemDetailContext,
+            ...problem
+        })
+    });

package/npm/aResponse.d.ts

@@ -0,0 +1,5 @@
+import type { HttpStatusCode } from '@nrfcloud/problem-detail';
+import type { APIGatewayProxyStructuredResultV2 } from 'aws-lambda';
+export declare const aResponse: (status: HttpStatusCode, result?: {
+    '@context': URL;
+} & Record<string, unknown>, cacheForSeconds?: number, headers?: APIGatewayProxyStructuredResultV2['headers']) => APIGatewayProxyStructuredResultV2;

package/npm/aResponse.js

@@ -0,0 +1,15 @@
+export const aResponse = (status, result, cacheForSeconds = 60, headers)=>{
+    const body = result !== undefined ? JSON.stringify(result) : undefined;
+    return {
+        statusCode: status,
+        headers: {
+            ...body !== undefined ? {
+                'content-type': 'application/json'
+            } : {},
+            'content-length': `${body?.length ?? 0}`,
+            'Cache-Control': cacheForSeconds > 0 ? `public, max-age=${cacheForSeconds}` : 'no-store',
+            ...headers ?? {}
+        },
+        body
+    };
+};

package/npm/addCORSHeaders.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareObj } from '@middy/core';
+import type { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2 } from 'aws-lambda';
+export declare const addCORSHeaders: (AccessControlAllowOrigin?: string, AccessControlExposeHeaders?: Array<string>) => MiddlewareObj<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;

package/npm/addCORSHeaders.js

@@ -0,0 +1,21 @@
+export const addCORSHeaders = (AccessControlAllowOrigin = '*', AccessControlExposeHeaders = [
+    'x-amzn-requestid',
+    'etag',
+    'apigw-requestid'
+])=>{
+    const setCORSHeaders = async (req)=>{
+        if (req.response === null) return;
+        req.response = {
+            ...req.response,
+            headers: {
+                ...req.response.headers ?? {},
+                'Access-Control-Allow-Origin': AccessControlAllowOrigin,
+                'Access-Control-Expose-Headers': AccessControlExposeHeaders.join(', ')
+            }
+        };
+    };
+    return {
+        after: setCORSHeaders,
+        onError: setCORSHeaders
+    };
+};

package/npm/addVersionHeader.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareObj } from '@middy/core';
+import type { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2 } from 'aws-lambda';
+export declare const addVersionHeader: (version: string) => MiddlewareObj<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;

package/npm/addVersionHeader.js

@@ -0,0 +1,16 @@
+export const addVersionHeader = (version)=>{
+    const setVersionHeader = async (req)=>{
+        if (req.response === null) return;
+        req.response = {
+            ...req.response,
+            headers: {
+                ...req.response.headers ?? {},
+                'x-backend-version': version
+            }
+        };
+    };
+    return {
+        after: setVersionHeader,
+        onError: setVersionHeader
+    };
+};

package/npm/corsHeaders.d.ts

@@ -0,0 +1,11 @@
+import type { APIGatewayProxyEventHeaders } from 'aws-lambda';
+export declare const corsHeaders: ({ headers, }: {
+    headers: APIGatewayProxyEventHeaders;
+}, allowedMethods?: string[], cacheForSeconds?: number) => {
+    'Access-Control-Allow-Headers': string;
+    'Access-Control-Expose-Headers': string;
+    'Access-Control-Allow-Methods': string;
+    'Access-Control-Allow-Origin': string;
+    'Access-Control-Max-Age': number;
+    Vary: 'Origin';
+};

package/npm/corsHeaders.js

@@ -0,0 +1,34 @@
+import { parseHeaders } from './parseHeaders.js';
+const allowedDomains = [
+    /^https?:\/\/localhost:/,
+    /^https:\/\/hello\.nrfcloud\.com$/
+];
+const defaultOrigin = 'https://hello.nrfcloud.com';
+const origin = (event)=>{
+    const origin = parseHeaders(event.headers).get('origin') ?? defaultOrigin.toString();
+    if (allowedDomains.find((rx)=>rx.test(origin)) !== undefined) return origin;
+    return defaultOrigin;
+};
+export const corsHeaders = ({ headers }, allowedMethods = [
+    'PUT',
+    'DELETE',
+    'POST',
+    'GET',
+    'PATCH'
+], cacheForSeconds = 600)=>({
+        'Access-Control-Allow-Origin': origin({
+            headers
+        }),
+        'Access-Control-Allow-Methods': allowedMethods.join(', '),
+        'Access-Control-Allow-Headers': Array.from(new Set([
+            'content-type',
+            'accept',
+            'if-match',
+            'authorization',
+            'origin'
+        ])).map((h)=>h.trim()).sort((h1, h2)=>h1.localeCompare(h2)).join(', '),
+        'Access-Control-Expose-Headers': 'x-amzn-requestid, etag, apigw-requestid',
+        'Access-Control-Max-Age': cacheForSeconds,
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin#cors_and_caching
+        Vary: 'Origin'
+    });

package/npm/corsOPTIONS.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareObj } from '@middy/core';
+import type { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2 } from 'aws-lambda';
+export declare const corsOPTIONS: (...allowedMethods: string[]) => MiddlewareObj<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;

package/npm/corsOPTIONS.js

@@ -0,0 +1,30 @@
+import { corsHeaders } from './corsHeaders.js';
+export const corsOPTIONS = (...allowedMethods)=>{
+    const setCorsHeaders = async (req)=>{
+        if (req.response === null) {
+            console.error(`[corsOPTIONS]`, `Response is null`);
+            return;
+        }
+        req.response = {
+            ...req.response,
+            headers: {
+                ...req.response?.headers ?? {},
+                ...corsHeaders(req.event, allowedMethods)
+            }
+        };
+    };
+    return {
+        before: async (req)=>{
+            if (req.event.requestContext.http.method === 'OPTIONS') {
+                console.debug(`[corsOPTIONS]`, `Handling OPTIONS request`);
+                return {
+                    statusCode: 200,
+                    headers: corsHeaders(req.event, allowedMethods)
+                };
+            }
+            return undefined;
+        },
+        after: setCorsHeaders,
+        onError: setCorsHeaders
+    };
+};

package/npm/corsResponse.d.ts

@@ -0,0 +1,4 @@
+import type { APIGatewayProxyEventHeaders, APIGatewayProxyStructuredResultV2 } from 'aws-lambda';
+export declare const corsResponse: (event: {
+    headers: APIGatewayProxyEventHeaders;
+}) => APIGatewayProxyStructuredResultV2;

package/npm/corsResponse.js

@@ -0,0 +1,5 @@
+import { corsHeaders } from './corsHeaders.js';
+export const corsResponse = (event)=>({
+        statusCode: 200,
+        headers: corsHeaders(event)
+    });

package/npm/export.d.ts

@@ -0,0 +1,15 @@
+export * from './addCORSHeaders.ts';
+export * from './addVersionHeader.ts';
+export * from './aProblem.ts';
+export * from './aResponse.ts';
+export * from './corsHeaders.ts';
+export * from './corsOPTIONS.ts';
+export * from './corsResponse.ts';
+export * from './logger.ts';
+export * from './metrics.ts';
+export * from './parseHeaders.ts';
+export * from './problemResponse.ts';
+export * from './requestLogger.ts';
+export * from './tryAsJSON.ts';
+export * from './validateInput.ts';
+export * from './validateResponse.ts';

package/npm/export.js

@@ -0,0 +1,15 @@
+export * from './addCORSHeaders.js';
+export * from './addVersionHeader.js';
+export * from './aProblem.js';
+export * from './aResponse.js';
+export * from './corsHeaders.js';
+export * from './corsOPTIONS.js';
+export * from './corsResponse.js';
+export * from './logger.js';
+export * from './metrics.js';
+export * from './parseHeaders.js';
+export * from './problemResponse.js';
+export * from './requestLogger.js';
+export * from './tryAsJSON.js';
+export * from './validateInput.js';
+export * from './validateResponse.js';

package/npm/logger.d.ts

@@ -0,0 +1,7 @@
+export type Logger = {
+    error: (message: string, detail?: unknown) => void;
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+};
+export declare const logger: (serviceName: string) => Logger;

package/npm/logger.js

@@ -0,0 +1,15 @@
+export const logger = (serviceName)=>({
+        error: (message, detail)=>{
+            console.error(`[${serviceName}]`, message);
+            if (detail !== undefined) console.error(JSON.stringify(detail));
+        },
+        debug: (...args)=>{
+            console.debug(`[${serviceName}]`, ...args.map((a)=>JSON.stringify(a)));
+        },
+        info: (...args)=>{
+            console.log(`[${serviceName}]`, ...args.map((a)=>JSON.stringify(a)));
+        },
+        warn: (...args)=>{
+            console.warn(`[${serviceName}]`, ...args.map((a)=>JSON.stringify(a)));
+        }
+    });

package/npm/metrics.d.ts

@@ -0,0 +1,9 @@
+import { Metrics } from '@aws-lambda-powertools/metrics';
+export type AddMetricsFn = (...args: Parameters<Metrics['addMetric']>) => void;
+/**
+ * Manages the instantiation of a Metrics object (unless Metrics are disabled)
+ */
+export declare const metricsForComponent: (component: string, namespace?: string) => {
+    metrics: Metrics;
+    track: AddMetricsFn;
+};

package/npm/metrics.js

@@ -0,0 +1,24 @@
+import { Metrics } from '@aws-lambda-powertools/metrics';
+const registry = {};
+/**
+ * Manages the instantiation of a Metrics object (unless Metrics are disabled)
+ */ export const metricsForComponent = (component, namespace = 'nrfcloud')=>{
+    const metricsEnabled = process.env.DISABLE_METRICS !== '1';
+    if (registry[component] === undefined) {
+        console.debug(`[Metrics]`, metricsEnabled ? `Enabled` : `Disabled`);
+        registry[component] = new Metrics({
+            namespace,
+            serviceName: component
+        });
+    }
+    const metrics = registry[component];
+    return {
+        metrics,
+        track: (...args)=>{
+            if (!metricsEnabled) {
+                return;
+            }
+            metrics.addMetric(...args);
+        }
+    };
+};

package/npm/parseHeaders.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a Map of headers with keys in lowercase.
+ * This is useful for consistent header handling, especially in environments
+ * where header keys may be case-insensitive.
+ */
+export declare const parseHeaders: (headers: Record<string, string | undefined> | null) => ParsedHeaders;
+export type ParsedHeaders = Pick<Map<string, string | null>, 'get' | 'has' | 'size' | 'keys' | 'values' | 'entries' | 'forEach'>;
+export declare const CaseInsensitiveMap: (map: Map<string, string | null>) => ParsedHeaders;

package/npm/parseHeaders.js

@@ -0,0 +1,20 @@
+/**
+ * Returns a Map of headers with keys in lowercase.
+ * This is useful for consistent header handling, especially in environments
+ * where header keys may be case-insensitive.
+ */ export const parseHeaders = (headers)=>{
+    if (headers === null) return new Map();
+    return CaseInsensitiveMap(Object.entries(headers).reduce((h, [key, value])=>{
+        h.set(key.toLowerCase(), value ?? null);
+        return h;
+    }, new Map()));
+};
+export const CaseInsensitiveMap = (map)=>({
+        get: (key)=>map.get(key.toLowerCase()),
+        has: (key)=>map.has(key.toLowerCase()),
+        size: map.size,
+        keys: ()=>map.keys(),
+        values: ()=>map.values(),
+        entries: ()=>map.entries(),
+        forEach: (callback, thisArg)=>map.forEach(callback, thisArg)
+    });

package/npm/problemResponse.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareObj } from '@middy/core';
+import type { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2, Context as LambdaContext } from 'aws-lambda';
+export declare const problemResponse: () => MiddlewareObj<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2, Error, LambdaContext>;

package/npm/problemResponse.js

@@ -0,0 +1,30 @@
+import { HttpStatusCode, ProblemDetailError } from '@nrfcloud/problem-detail';
+import { formatTypeBoxErrors } from '@nrfcloud/validate-with-typebox';
+import { aProblem } from './aProblem.js';
+import { ValidationFailedError } from './validateInput.js';
+import { ResponseValidationFailedError } from './validateResponse.js';
+export const problemResponse = ()=>({
+        onError: async (req)=>{
+            if (req.response !== undefined) return;
+            if (req.error instanceof ResponseValidationFailedError) {
+                req.response = aProblem({
+                    title: 'Response validation failed',
+                    status: HttpStatusCode.INTERNAL_SERVER_ERROR,
+                    detail: formatTypeBoxErrors(req.error.errors)
+                });
+            } else if (req.error instanceof ValidationFailedError) {
+                req.response = aProblem({
+                    title: 'Validation failed',
+                    status: HttpStatusCode.BAD_REQUEST,
+                    detail: formatTypeBoxErrors(req.error.errors)
+                });
+            } else if (req.error instanceof ProblemDetailError) {
+                req.response = aProblem(req.error.problem);
+            } else {
+                req.response = aProblem({
+                    title: req.error instanceof Error ? req.error.message : 'Internal Server Error',
+                    status: HttpStatusCode.INTERNAL_SERVER_ERROR
+                });
+            }
+        }
+    });

package/npm/requestLogger.d.ts

@@ -0,0 +1,2 @@
+import inputOutputLogger from '@middy/input-output-logger';
+export declare const requestLogger: () => ReturnType<typeof inputOutputLogger>;

package/npm/requestLogger.js

@@ -0,0 +1,4 @@
+import inputOutputLogger from '@middy/input-output-logger';
+export const requestLogger = ()=>inputOutputLogger({
+        logger: (message)=>console.debug(JSON.stringify(message))
+    });

package/npm/tryAsJSON.d.ts

@@ -0,0 +1 @@
+export declare const tryAsJSON: (body: unknown) => Record<string, any> | null;

package/npm/tryAsJSON.js

@@ -0,0 +1,8 @@
+export const tryAsJSON = (body)=>{
+    if (typeof body !== 'string') return null;
+    try {
+        return JSON.parse(body);
+    } catch  {
+        return null;
+    }
+};

package/npm/validateInput.d.ts

@@ -0,0 +1,18 @@
+import type { MiddlewareObj } from '@middy/core';
+import type { Static, StaticDecode, TSchema } from '@sinclair/typebox';
+import type { ValueError } from '@sinclair/typebox/compiler';
+import type { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2, Context } from 'aws-lambda';
+export declare class ValidationFailedError extends Error {
+    readonly errors: ValueError[];
+    constructor(errors: ValueError[], message?: string);
+}
+export declare const validateInput: <Schema extends TSchema>(schema: Schema, mapInput?: (e: APIGatewayProxyEventV2) => unknown) => MiddlewareObj<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2, Error, Context & ValidInput<Schema>>;
+export type ValidInput<Schema extends TSchema> = {
+    /**
+     * @deprecated Use `decodedInput` instead
+     *
+     * This will be removed in the next major version.
+     */
+    validInput: Static<Schema>;
+    decodedInput: StaticDecode<Schema>;
+};

package/npm/validateInput.js

@@ -0,0 +1,44 @@
+import { formatTypeBoxErrors, validateWithTypeBox } from '@nrfcloud/validate-with-typebox';
+import { Value } from '@sinclair/typebox/value';
+import { parseHeaders } from './parseHeaders.js';
+import { tryAsJSON } from './tryAsJSON.js';
+export class ValidationFailedError extends Error {
+    errors;
+    constructor(errors, message = 'Validation failed'){
+        super(message);
+        this.errors = errors;
+        this.name = 'ValidationFailedError';
+    }
+}
+export const validateInput = (schema, mapInput)=>{
+    const v = validateWithTypeBox(schema);
+    return {
+        before: async (req)=>{
+            let reqBody = {};
+            const headers = parseHeaders(req.event.headers);
+            const contentType = headers.get('content-type') ?? '';
+            if (contentType.includes('application/json') && (req.event.body?.length ?? 0) >= 2 // should be at least '{}'
+            ) {
+                reqBody = tryAsJSON(req.event.body) ?? {};
+            }
+            const input = mapInput?.(req.event) ?? {
+                ...req.event.pathParameters ?? {},
+                ...req.event.queryStringParameters ?? {},
+                ...reqBody
+            };
+            console.debug(`[validateInput]`, 'input', JSON.stringify(input));
+            const maybeValidInput = v(input);
+            if ('errors' in maybeValidInput) {
+                console.debug(`[validateInput]`, `Input not valid`, JSON.stringify({
+                    input,
+                    errors: formatTypeBoxErrors(maybeValidInput.errors)
+                }), schema.title);
+                throw new ValidationFailedError(maybeValidInput.errors);
+            }
+            console.debug(`[validateInput]`, `Input is valid`, schema.title);
+            req.context.validInput = maybeValidInput.value;
+            req.context.decodedInput = Value.Decode(schema, maybeValidInput.value);
+            return undefined;
+        }
+    };
+};

package/npm/validateResponse.d.ts

@@ -0,0 +1,11 @@
+import type middy from '@middy/core';
+import type { TSchema } from '@sinclair/typebox';
+import type { ValueError } from '@sinclair/typebox/errors';
+import { ValidationFailedError } from './validateInput.ts';
+export declare class ResponseValidationFailedError extends ValidationFailedError {
+    constructor(errors: ValueError[]);
+}
+/**
+ * Validate responses created with `aResponse`
+ */
+export declare const validateResponse: <ResponseSchema extends TSchema>(schema: ResponseSchema) => middy.MiddlewareObj;

package/npm/validateResponse.js

@@ -0,0 +1,35 @@
+import { formatTypeBoxErrors, validateWithTypeBox } from '@nrfcloud/validate-with-typebox';
+import { parseHeaders } from './parseHeaders.js';
+import { tryAsJSON } from './tryAsJSON.js';
+import { ValidationFailedError } from './validateInput.js';
+export class ResponseValidationFailedError extends ValidationFailedError {
+    constructor(errors){
+        super(errors, 'Response validation failed');
+        this.name = 'ResponseValidationFailedError';
+    }
+}
+/**
+ * Validate responses created with `aResponse`
+ */ export const validateResponse = (schema)=>{
+    const validator = validateWithTypeBox(schema);
+    return {
+        after: async (req)=>{
+            const body = req.response?.body;
+            const headers = parseHeaders(req.response.headers);
+            const contentType = headers.get('content-type') ?? '';
+            if ((body?.length ?? 0) === 0) {
+                console.debug(`[validateResponse]`, `Response body is empty`);
+            }
+            if ((contentType?.includes('application/json') ?? false) === false) {
+                console.debug(`[validateResponse]`, `Response body is not JSON`);
+            }
+            const maybeValid = validator(tryAsJSON(req.response.body));
+            if ('errors' in maybeValid) {
+                console.error(`[validateResponse]`, `Response validation failed`, req.response.body, formatTypeBoxErrors(maybeValid.errors), schema.title);
+                throw new ResponseValidationFailedError(maybeValid.errors);
+            }
+            console.debug(`[validateResponse]`, `Response is valid`, schema.title);
+            return undefined;
+        }
+    };
+};

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@nrfcloud/lambda-helpers",
+  "version": "1.0.28",
+  "description": "Helper functions for AWS Lambda functions used in nRF Cloud.",
+  "homepage": "https://github.com/nrfcloud/lambda-helpers#readme",
+  "bugs": {
+    "url": "https://github.com/nrfcloud/lambda-helpers/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nrfcloud/lambda-helpers.git"
+  },
+  "author": "Nordic Semiconductor ASA | nordicsemi.no",
+  "scripts": {
+    "test": "node --no-warnings --experimental-transform-types --test \"./*.spec.ts\" \"./.npm/*.spec.ts\"",
+    "prepublishOnly": "node --experimental-strip-types ./.npm/compile.ts && npx tsc -P ./.npm/tsconfig.npm.json --outDir ./npm"
+  },
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./npm/export.d.ts",
+        "default": "./npm/export.js"
+      }
+    }
+  },
+  "files": [
+    "npm",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@bifravst/prettier-config": "1.1.17",
+    "@nrfcloud/validate-with-typebox": "npm:@jsr/nrfcloud__validate-with-typebox@^1.0.5",
+    "@swc/core": "1.15.47",
+    "@types/aws-lambda": "8.10.162",
+    "@types/node": "25.9.5",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "prettier": "3.9.6",
+    "typescript": "npm:@typescript/typescript6@6.0.2"
+  },
+  "prettier": "@bifravst/prettier-config",
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "remoteTags": true,
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      [
+        "@semantic-release/github",
+        {
+          "successCommentCondition": false,
+          "failCommentCondition": false
+        }
+      ]
+    ]
+  },
+  "engines": {
+    "node": ">=24.18.1 <25",
+    "npm": ">=12.0.2 <13"
+  },
+  "dependencies": {
+    "@aws-lambda-powertools/metrics": "2.34.0",
+    "@middy/core": "7.7.2",
+    "@middy/input-output-logger": "7.7.2",
+    "@nrfcloud/problem-detail": "npm:@jsr/nrfcloud__problem-detail@1.4.2",
+    "@sinclair/typebox": "0.34.52"
+  }
+}