@bifravst/http-api-mock 3.0.4 → 3.0.6

package/npm/cdk/App.d.ts

@@ -0,0 +1,11 @@
+import type { PackedLambda } from '@bifravst/aws-cdk-lambda-helpers';
+import type { PackedLayer } from '@bifravst/aws-cdk-lambda-helpers/layer';
+import { App } from 'aws-cdk-lib';
+export declare class HTTPAPIMockApp extends App {
+    constructor(stackName: string, { lambdaSources, layer, }: {
+        lambdaSources: {
+            httpApiMock: PackedLambda;
+        };
+        layer: PackedLayer;
+    });
+}

package/npm/cdk/App.js

@@ -1,15 +1,12 @@
 import { App } from 'aws-cdk-lib';
 import { HTTPAPIMockStack } from './Stack.js';
 export class HTTPAPIMockApp extends App {
-    constructor(stackName, { lambdaSources, layer }){
+    constructor(stackName, { lambdaSources, layer, }) {
         super({
             context: {
-                isTest: true
-            }
-        });
-        new HTTPAPIMockStack(this, stackName, {
-            lambdaSources,
-            layer
+                isTest: true,
+            },
         });
+        new HTTPAPIMockStack(this, stackName, { lambdaSources, layer });
     }
 }

package/npm/cdk/Stack.d.ts

@@ -0,0 +1,20 @@
+import type { PackedLambda } from '@bifravst/aws-cdk-lambda-helpers';
+import type { PackedLayer } from '@bifravst/aws-cdk-lambda-helpers/layer';
+import type { App } from 'aws-cdk-lib';
+import { Stack } from 'aws-cdk-lib';
+/**
+ * This is CloudFormation stack sets up a dummy HTTP API which stores all requests in SQS for inspection
+ */
+export declare class HTTPAPIMockStack extends Stack {
+    constructor(parent: App, stackName: string, { lambdaSources, layer, }: {
+        lambdaSources: {
+            httpApiMock: PackedLambda;
+        };
+        layer: PackedLayer;
+    });
+}
+export type StackOutputs = {
+    apiURL: string;
+    requestsTableName: string;
+    responsesTableName: string;
+};

package/npm/cdk/Stack.js

@@ -3,43 +3,38 @@ import { CfnOutput, aws_lambda as Lambda, Stack } from 'aws-cdk-lib';
 import { HttpApiMock } from './resources/HttpApiMock.js';
 /**
  * This is CloudFormation stack sets up a dummy HTTP API which stores all requests in SQS for inspection
- */ export class HTTPAPIMockStack extends Stack {
-    constructor(parent, stackName, { lambdaSources, layer }){
+ */
+export class HTTPAPIMockStack extends Stack {
+    constructor(parent, stackName, { lambdaSources, layer, }) {
         super(parent, stackName, {
-            description: 'Provides a mock HTTP API for testing third-party API integrations.'
+            description: 'Provides a mock HTTP API for testing third-party API integrations.',
         });
         const baseLayer = new Lambda.LayerVersion(this, 'baseLayer', {
             layerVersionName: `${Stack.of(this).stackName}-baseLayer`,
             code: new LambdaSource(this, {
                 id: 'baseLayer',
                 zipFilePath: layer.layerZipFilePath,
-                hash: layer.hash
+                hash: layer.hash,
             }).code,
-            compatibleArchitectures: [
-                Lambda.Architecture.ARM_64
-            ],
-            compatibleRuntimes: [
-                Lambda.Runtime.NODEJS_24_X
-            ]
+            compatibleArchitectures: [Lambda.Architecture.ARM_64],
+            compatibleRuntimes: [Lambda.Runtime.NODEJS_24_X],
         });
         const httpMockApi = new HttpApiMock(this, {
             lambdaSources,
-            layers: [
-                baseLayer
-            ]
+            layers: [baseLayer],
         });
         // Export these so the test runner can use them
         new CfnOutput(this, 'apiURL', {
             value: httpMockApi.api.url,
-            exportName: `${this.stackName}:apiURL`
+            exportName: `${this.stackName}:apiURL`,
         });
         new CfnOutput(this, 'responsesTableName', {
             value: httpMockApi.responsesTable.tableName,
-            exportName: `${this.stackName}:responsesTableName`
+            exportName: `${this.stackName}:responsesTableName`,
         });
         new CfnOutput(this, 'requestsTableName', {
             value: httpMockApi.requestsTable.tableName,
-            exportName: `${this.stackName}:requestsTableName`
+            exportName: `${this.stackName}:requestsTableName`,
         });
     }
 }

package/npm/cdk/http-api-mock.d.ts

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

package/npm/cdk/http-api-mock.js

@@ -9,33 +9,37 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import pJSON from '../package.json' with { type: 'json' };
 import { randomString } from '../src/randomString.js';
 import { HTTPAPIMockApp } from './App.js';
 const options = commandLineArgs([
     {
         name: 'config',
         type: Boolean,
-        defaultValue: false
+        defaultValue: false,
     },
     {
         name: 'destroy',
         type: Boolean,
-        defaultValue: false
-    }
+        defaultValue: false,
+    },
 ]);
-const loadConfig = async ()=>{
+const loadConfig = async () => {
     try {
         const config = JSON.parse(await fs.readFile(path.join(process.cwd(), 'http-api-mock.json'), 'utf-8'));
         return config;
-    } catch  {
+    }
+    catch {
         return {};
     }
 };
-const stackName = process.env.HTTP_API_MOCK_STACK_NAME ?? (await loadConfig())?.stackName ?? `http-api-mock-${randomString()}`;
-const saveConfig = async ()=>{
+const stackName = process.env.HTTP_API_MOCK_STACK_NAME ??
+    (await loadConfig())?.stackName ??
+    `http-api-mock-${randomString()}`;
+const saveConfig = async () => {
     writeFileSync(path.join(process.cwd(), 'http-api-mock.json'), JSON.stringify({
         stackName,
-        ...await stackOutput(new CloudFormationClient({}))(stackName)
+        ...(await stackOutput(new CloudFormationClient({}))(stackName)),
     }, null, 2));
 };
 if (options.config === true) {
@@ -49,7 +53,7 @@ await fs.mkdir(lambdasDir);
 const layersDir = path.join(distDir, 'layers');
 await fs.mkdir(layersDir);
 const dependencies = [
-    '@bifravst/from-env'
+    '@bifravst/from-env',
 ];
 const app = new HTTPAPIMockApp(stackName, {
     lambdaSources: {
@@ -57,21 +61,22 @@ const app = new HTTPAPIMockApp(stackName, {
             id: 'httpApiMock',
             sourceFilePath: 'cdk/resources/http-api-mock-lambda.ts',
             baseDir,
-            distDir: lambdasDir
-        })
+            distDir: lambdasDir,
+        }),
     },
     layer: await packLayer({
         id: 'testResources',
         dependencies,
         baseDir,
-        distDir: layersDir
-    })
+        distDir: layersDir,
+    }),
 });
 const cdk = new Toolkit();
-const cx = await cdk.fromAssemblyBuilder(async ()=>app.synth());
+const cx = await cdk.fromAssemblyBuilder(async () => app.synth());
 if (options.destroy === true) {
     await cdk.destroy(cx);
-} else {
+}
+else {
     await cdk.deploy(cx);
     await saveConfig();
 }

package/npm/cdk/resources/HttpApiMock.d.ts

@@ -0,0 +1,14 @@
+import type { PackedLambda } from '@bifravst/aws-cdk-lambda-helpers';
+import { aws_apigateway as ApiGateway, aws_dynamodb as DynamoDB, aws_lambda as Lambda, Resource } from 'aws-cdk-lib';
+import type { Construct } from 'constructs';
+export declare class HttpApiMock extends Resource {
+    readonly api: ApiGateway.RestApi;
+    readonly requestsTable: DynamoDB.Table;
+    readonly responsesTable: DynamoDB.Table;
+    constructor(parent: Construct, { lambdaSources, layers, }: {
+        lambdaSources: {
+            httpApiMock: PackedLambda;
+        };
+        layers: Lambda.ILayerVersion[];
+    });
+}

package/npm/cdk/resources/HttpApiMock.js

@@ -1,53 +1,53 @@
-import { LambdaLogGroup, LambdaSource } from '@bifravst/aws-cdk-lambda-helpers/cdk';
-import { aws_apigateway as ApiGateway, Duration, aws_dynamodb as DynamoDB, aws_iam as IAM, aws_lambda as Lambda, aws_logs as Logs, RemovalPolicy, Resource } from 'aws-cdk-lib';
+import { LambdaLogGroup, LambdaSource, } from '@bifravst/aws-cdk-lambda-helpers/cdk';
+import { aws_apigateway as ApiGateway, Duration, aws_dynamodb as DynamoDB, aws_iam as IAM, aws_lambda as Lambda, aws_logs as Logs, RemovalPolicy, Resource, } from 'aws-cdk-lib';
 export class HttpApiMock extends Resource {
     api;
     requestsTable;
     responsesTable;
-    constructor(parent, { lambdaSources, layers }){
+    constructor(parent, { lambdaSources, layers, }) {
         super(parent, 'http-api-mock');
         // This table will store all the requests made to the API Gateway
         this.requestsTable = new DynamoDB.Table(this, 'requests', {
             billingMode: DynamoDB.BillingMode.PAY_PER_REQUEST,
             partitionKey: {
                 name: 'requestId',
-                type: DynamoDB.AttributeType.STRING
+                type: DynamoDB.AttributeType.STRING,
             },
             sortKey: {
                 name: 'timestamp',
-                type: DynamoDB.AttributeType.STRING
+                type: DynamoDB.AttributeType.STRING,
             },
-            removalPolicy: RemovalPolicy.DESTROY
+            removalPolicy: RemovalPolicy.DESTROY,
         });
         this.requestsTable.addGlobalSecondaryIndex({
             indexName: 'methodPathQuery',
             partitionKey: {
                 name: 'methodPathQuery',
-                type: DynamoDB.AttributeType.STRING
+                type: DynamoDB.AttributeType.STRING,
             },
-            projectionType: DynamoDB.ProjectionType.ALL
+            projectionType: DynamoDB.ProjectionType.ALL,
         });
         // This table will store optional responses to be sent
         this.responsesTable = new DynamoDB.Table(this, 'responses', {
             billingMode: DynamoDB.BillingMode.PAY_PER_REQUEST,
             partitionKey: {
                 name: 'responseId',
-                type: DynamoDB.AttributeType.STRING
+                type: DynamoDB.AttributeType.STRING,
             },
             sortKey: {
                 name: 'timestamp',
-                type: DynamoDB.AttributeType.STRING
+                type: DynamoDB.AttributeType.STRING,
             },
             removalPolicy: RemovalPolicy.DESTROY,
-            timeToLiveAttribute: 'ttl'
+            timeToLiveAttribute: 'ttl',
         });
         this.responsesTable.addGlobalSecondaryIndex({
             indexName: 'methodPathQuery',
             partitionKey: {
                 name: 'methodPathQuery',
-                type: DynamoDB.AttributeType.STRING
+                type: DynamoDB.AttributeType.STRING,
             },
-            projectionType: DynamoDB.ProjectionType.ALL
+            projectionType: DynamoDB.ProjectionType.ALL,
         });
         // This lambda will publish all requests made to the API Gateway in the queue
         const lambda = new Lambda.Function(this, 'Lambda', {
@@ -62,9 +62,9 @@ export class HttpApiMock extends Resource {
                 REQUESTS_TABLE_NAME: this.requestsTable.tableName,
                 RESPONSES_TABLE_NAME: this.responsesTable.tableName,
                 LOG_LEVEL: this.node.tryGetContext('logLevel'),
-                NODE_NO_WARNINGS: '1'
+                NODE_NO_WARNINGS: '1',
             },
-            ...new LambdaLogGroup(this, 'LambdaLogs', Logs.RetentionDays.ONE_DAY)
+            ...new LambdaLogGroup(this, 'LambdaLogs', Logs.RetentionDays.ONE_DAY),
         });
         this.responsesTable.grantReadWriteData(lambda);
         this.requestsTable.grantReadWriteData(lambda);
@@ -72,16 +72,14 @@ export class HttpApiMock extends Resource {
         this.api = new ApiGateway.RestApi(this, 'api', {
             restApiName: `HTTP Mock API for testing`,
             description: 'API Gateway to test outgoing requests',
-            binaryMediaTypes: [
-                'application/octet-stream'
-            ]
+            binaryMediaTypes: ['application/octet-stream'],
         });
         const proxyResource = this.api.root.addResource('{proxy+}');
         proxyResource.addMethod('ANY', new ApiGateway.LambdaIntegration(lambda));
         // API Gateway needs to be able to call the lambda
         lambda.addPermission('InvokeByApiGateway', {
             principal: new IAM.ServicePrincipal('apigateway.amazonaws.com'),
-            sourceArn: this.api.arnForExecuteApi()
+            sourceArn: this.api.arnForExecuteApi(),
         });
     }
 }

package/npm/cdk/resources/checkMatchingQueryParams.d.ts

@@ -0,0 +1,5 @@
+type Logger = {
+    debug: (...arg: any) => void;
+};
+export declare const checkMatchingQueryParams: (actual: Record<string, unknown> | null, expected: Record<string, unknown>, log?: Logger) => boolean;
+export {};

package/npm/cdk/resources/checkMatchingQueryParams.js

@@ -1,30 +1,32 @@
 const matchRegex = /^\/(?<re>.+)\/(?<option>[gi])?$/;
-export const checkMatchingQueryParams = (actual, expected, log)=>{
-    log?.debug('checkMatchingQueryParams', {
-        actual,
-        expected
-    });
-    if (actual === null) return false;
+export const checkMatchingQueryParams = (actual, expected, log) => {
+    log?.debug('checkMatchingQueryParams', { actual, expected });
+    if (actual === null)
+        return false;
     // Check whether expected query parameters is subset of actual query parameters
-    for(const prop in expected){
+    for (const prop in expected) {
         const expectedValue = expected[prop];
         const actualValue = actual?.[prop];
-        if (actualValue === undefined) return false;
+        if (actualValue === undefined)
+            return false;
         if (typeof expectedValue === 'string') {
             const match = matchRegex.exec(expectedValue);
             if (match !== null) {
-                log?.debug('Compare using regex', {
-                    expectedValue
-                });
+                log?.debug('Compare using regex', { expectedValue });
                 // Expect is regex
                 const check = new RegExp(match?.groups?.re ?? '', match?.groups?.option).test(String(actualValue));
-                if (check === false) return false;
-            } else {
-                if (actualValue !== expectedValue) return false;
+                if (check === false)
+                    return false;
             }
-        } else {
+            else {
+                if (actualValue !== expectedValue)
+                    return false;
+            }
+        }
+        else {
             // All query parameters are string
-            if (actualValue !== String(expectedValue)) return false;
+            if (actualValue !== String(expectedValue))
+                return false;
         }
     }
     return true;

package/npm/cdk/resources/checkMatchingQueryParams.spec.d.ts

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

package/npm/cdk/resources/checkMatchingQueryParams.spec.js

@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { checkMatchingQueryParams } from './checkMatchingQueryParams.js';
+void describe('checkMatchingQueryParams', () => {
+    void it('should return true when expected is subset of actual parameters', () => {
+        const actual = {
+            param1: 'value1',
+            param2: 'value2',
+        };
+        const expected = {
+            param1: 'value1',
+        };
+        const result = checkMatchingQueryParams(actual, expected);
+        assert.equal(result, true);
+    });
+    void it('should return true when expected contains regular expression and it matches', () => {
+        const actual = {
+            param1: 'value1,value2,value3',
+        };
+        const expected = {
+            param1: '/\\bvalue2\\b/',
+        };
+        const result = checkMatchingQueryParams(actual, expected);
+        assert.equal(result, true);
+    });
+    void it('should return false when expected does not match actual parameters', () => {
+        const actual = {
+            param1: 'value1',
+            param2: 'value2',
+        };
+        const expected = {
+            param1: 'value2',
+        };
+        const result = checkMatchingQueryParams(actual, expected);
+        assert.equal(result, false);
+    });
+    void it('should return false when actual is null', () => {
+        const actual = null;
+        const expected = {
+            param1: 'value1',
+        };
+        const result = checkMatchingQueryParams(actual, expected);
+        assert.equal(result, false);
+    });
+    void it('should return true when expected parameters having number or boolean', () => {
+        const actual = {
+            param1: 'true',
+            param2: '1',
+        };
+        const expected = {
+            param1: true,
+            param2: 1,
+        };
+        const result = checkMatchingQueryParams(actual, expected);
+        assert.equal(result, true);
+    });
+});

package/npm/cdk/resources/http-api-mock-lambda.d.ts

@@ -0,0 +1,2 @@
+import type { APIGatewayEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
+export declare const handler: (event: APIGatewayEvent, context: Context) => Promise<APIGatewayProxyResult>;

package/npm/cdk/resources/http-api-mock-lambda.js

@@ -1,15 +1,16 @@
-import { DeleteItemCommand, DynamoDBClient, PutItemCommand, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { DeleteItemCommand, DynamoDBClient, PutItemCommand, ScanCommand, } from '@aws-sdk/client-dynamodb';
 import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
 import { URLSearchParams } from 'url';
 import { sortQueryString } from '../../src/sortQueryString.js';
 import { checkMatchingQueryParams } from './checkMatchingQueryParams.js';
 import { splitMockResponse } from './splitMockResponse.js';
 const db = new DynamoDBClient({});
-export const handler = async (event, context)=>{
-    console.log(JSON.stringify({
-        event
-    }));
-    const query = event.queryStringParameters !== null && event.queryStringParameters !== undefined ? new URLSearchParams(event.queryStringParameters) : undefined;
+export const handler = async (event, context) => {
+    console.log(JSON.stringify({ event }));
+    const query = event.queryStringParameters !== null &&
+        event.queryStringParameters !== undefined
+        ? new URLSearchParams(event.queryStringParameters)
+        : undefined;
     const path = event.path.replace(/^\//, '');
     const pathWithQuery = sortQueryString(`${path}${query !== undefined ? `?${query.toString()}` : ''}`);
     const request = {
@@ -20,7 +21,7 @@ export const handler = async (event, context)=>{
         path,
         query: query === undefined ? null : Object.fromEntries(query),
         body: event.body ?? '{}',
-        headers: JSON.stringify(event.headers)
+        headers: JSON.stringify(event.headers),
     };
     // Check if response exists
     console.debug(`Checking if response exists for ${event.httpMethod} ${pathWithQuery}...`);
@@ -30,31 +31,36 @@ export const handler = async (event, context)=>{
         FilterExpression: 'begins_with(methodPathQuery, :methodPath)',
         ExpressionAttributeValues: {
             [':methodPath']: {
-                S: `${event.httpMethod} ${path}`
-            }
-        }
+                S: `${event.httpMethod} ${path}`,
+            },
+        },
     }));
     console.debug(`Found response items beginning with same path: ${Items?.length}`);
     // use newest response first
-    const itemsByTimestampDesc = (Items ?? []).map((Item)=>unmarshall(Item)).sort((a, b)=>b.timestamp.localeCompare(a.timestamp));
+    const itemsByTimestampDesc = (Items ?? [])
+        .map((Item) => unmarshall(Item))
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp));
     let res = {
         statusCode: 404,
-        body: 'No responses found'
+        body: 'No responses found',
     };
-    for (const objItem of itemsByTimestampDesc){
+    for (const objItem of itemsByTimestampDesc) {
         const hasExpectedQueryParams = 'queryParams' in objItem || query !== undefined;
-        const matchedQueryParams = hasExpectedQueryParams ? checkMatchingQueryParams(event.queryStringParameters, objItem.queryParams) : true;
-        if (matchedQueryParams === false) continue;
-        console.debug(`Matched response`, JSON.stringify({
-            response: objItem
-        }));
-        if (objItem?.requestId !== undefined && objItem?.timestamp !== undefined && objItem?.keep !== true) {
+        const matchedQueryParams = hasExpectedQueryParams
+            ? checkMatchingQueryParams(event.queryStringParameters, objItem.queryParams)
+            : true;
+        if (matchedQueryParams === false)
+            continue;
+        console.debug(`Matched response`, JSON.stringify({ response: objItem }));
+        if (objItem?.requestId !== undefined &&
+            objItem?.timestamp !== undefined &&
+            objItem?.keep !== true) {
             await db.send(new DeleteItemCommand({
                 TableName: process.env.RESPONSES_TABLE_NAME,
                 Key: marshall({
                     requestId: objItem.requestId,
-                    timestamp: objItem.timestamp
-                })
+                    timestamp: objItem.timestamp,
+                }),
             }));
         }
         const { body, headers } = splitMockResponse(objItem.body ?? '');
@@ -62,18 +68,20 @@ export const handler = async (event, context)=>{
         const isBinary = /^[0-9a-f]+$/.test(body);
         res = {
             statusCode: objItem.statusCode ?? 200,
-            headers: isBinary ? {
-                ...headers,
-                'Content-Type': 'application/octet-stream'
-            } : headers,
-            body: isBinary ? /* body is HEX encoded */ Buffer.from(body, 'hex').toString('base64') : body,
-            isBase64Encoded: isBinary
+            headers: isBinary
+                ? {
+                    ...headers,
+                    'Content-Type': 'application/octet-stream',
+                }
+                : headers,
+            body: isBinary
+                ? /* body is HEX encoded */ Buffer.from(body, 'hex').toString('base64')
+                : body,
+            isBase64Encoded: isBinary,
         };
         break;
     }
-    console.debug(`Return response`, JSON.stringify({
-        response: res
-    }));
+    console.debug(`Return response`, JSON.stringify({ response: res }));
     await db.send(new PutItemCommand({
         TableName: process.env.REQUESTS_TABLE_NAME,
         Item: marshall({
@@ -81,10 +89,10 @@ export const handler = async (event, context)=>{
             responseStatusCode: res.statusCode,
             responseHeaders: res.headers,
             responseBody: res.body,
-            responseIsBase64Encoded: res.isBase64Encoded
+            responseIsBase64Encoded: res.isBase64Encoded,
         }, {
-            removeUndefinedValues: true
-        })
+            removeUndefinedValues: true,
+        }),
     }));
     return res;
 };

package/npm/cdk/resources/splitMockResponse.d.ts

@@ -0,0 +1,4 @@
+export declare const splitMockResponse: (r: string) => {
+    headers: Record<string, string>;
+    body: string;
+};

package/npm/cdk/resources/splitMockResponse.js

@@ -1,15 +1,20 @@
-export const splitMockResponse = (r)=>{
-    const trimmedLines = r.split('\n').map((s)=>s.trim()).join('\n');
+export const splitMockResponse = (r) => {
+    const trimmedLines = r
+        .split('\n')
+        .map((s) => s.trim())
+        .join('\n');
     const blankLineLocation = trimmedLines.indexOf('\n\n');
-    if (blankLineLocation === -1) return {
-        headers: {},
-        body: trimmedLines
-    };
+    if (blankLineLocation === -1)
+        return {
+            headers: {},
+            body: trimmedLines,
+        };
     return {
-        headers: trimmedLines.slice(0, blankLineLocation).split('\n').map((s)=>s.split(':', 2)).reduce((headers, [k, v])=>({
-                ...headers,
-                [k]: v?.trim()
-            }), {}),
-        body: trimmedLines.slice(blankLineLocation + 2)
+        headers: trimmedLines
+            .slice(0, blankLineLocation)
+            .split('\n')
+            .map((s) => s.split(':', 2))
+            .reduce((headers, [k, v]) => ({ ...headers, [k]: v?.trim() }), {}),
+        body: trimmedLines.slice(blankLineLocation + 2),
     };
 };

package/npm/cdk/resources/splitMockResponse.spec.d.ts

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

package/npm/cdk/resources/splitMockResponse.spec.js

@@ -0,0 +1,13 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { splitMockResponse } from './splitMockResponse.js';
+void describe('split mock response', () => {
+    void it('should parse headers and body', () => assert.deepEqual(splitMockResponse(`Content-Type: application/octet-stream
+
+(binary A-GNSS data) other types`), {
+        headers: {
+            'Content-Type': 'application/octet-stream',
+        },
+        body: '(binary A-GNSS data) other types',
+    }));
+});

package/npm/e2e.spec.d.ts

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

package/npm/e2e.spec.js

@@ -0,0 +1,51 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { listRequests } from './src/requests.js';
+import { registerResponse } from './src/responses.js';
+const { responsesTableName, apiURL, requestsTableName } = JSON.parse(await readFile(path.join(process.cwd(), 'http-api-mock.json'), 'utf-8'));
+const db = new DynamoDBClient({});
+void describe('end-to-end tests', () => {
+    void it('should respond with 404 if no response is configured', async () => {
+        const res = await fetch(new URL('/prod/foo', apiURL), {
+            method: 'POST',
+            body: JSON.stringify({ some: 'data' }),
+            headers: {
+                'content-type': 'application/json; charset=utf-8',
+            },
+        });
+        assert.equal(res.ok, false);
+        assert.equal(res.status, 404);
+    });
+    void it('should store all requests', async () => {
+        const pathSegment = crypto.randomUUID();
+        await fetch(new URL(`/prod/${pathSegment}`, apiURL));
+        const request = (await listRequests(db, requestsTableName)).find(({ path }) => path === pathSegment);
+        assert.notEqual(request, undefined);
+    });
+    void it('should return a configured response', async () => {
+        const pathSegment = crypto.randomUUID();
+        await registerResponse(db, responsesTableName, {
+            method: 'PUT',
+            path: pathSegment,
+            queryParams: new URLSearchParams({
+                foo: 'bar',
+            }),
+            body: [
+                `Content-Type: application/json`,
+                '',
+                JSON.stringify({ success: true }),
+            ].join('\n'),
+            statusCode: 201,
+        });
+        const res = await fetch(new URL(`/prod/${pathSegment}?${new URLSearchParams({ foo: 'bar' }).toString()}`, apiURL), {
+            method: 'PUT',
+        });
+        assert.equal(res.ok, true);
+        assert.equal(res.status, 201);
+        assert.equal(res.headers.get('Content-Type'), 'application/json');
+        assert.deepEqual(await res.json(), { success: true });
+    });
+});

package/npm/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@bifravst/http-api-mock",
+  "version": "3.0.6",
+  "description": "Helper functions for AWS lambdas written in TypeScript.",
+  "exports": {
+    "./*": {
+      "import": {
+        "default": "./npm/src/*.js",
+        "types": "./npm/src/*.d.ts"
+      }
+    }
+  },
+  "type": "module",
+  "scripts": {
+    "prepare": "husky && case \"$npm_command\" in install|ci) check-node-version --package ;; esac",
+    "prepublishOnly": "npx tsc --noEmit false --outDir ./npm -d && cp -rv cdk/* npm/cdk && cp package.json npm/package.json",
+    "test": "node --no-warnings --experimental-transform-types --test \"!(node_modules|e2e-tests|integration-tests)/**/*.spec.ts\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bifravst/http-api-mock.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bifravst/http-api-mock/issues"
+  },
+  "homepage": "https://github.com/bifravst/http-api-mock",
+  "keywords": [
+    "aws",
+    "lambda",
+    "typescript"
+  ],
+  "author": "Nordic Semiconductor ASA | nordicsemi.no",
+  "license": "BSD-3-Clause",
+  "lint-staged": {
+    "*.ts": [
+      "prettier --write",
+      "eslint"
+    ],
+    "*.{md,json,yaml,yml}": [
+      "prettier --write"
+    ]
+  },
+  "engines": {
+    "node": ">=24.19.0 <25",
+    "npm": ">=12.0.2 <13"
+  },
+  "release": {
+    "branches": [
+      "saga"
+    ],
+    "remoteTags": true,
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      [
+        "@semantic-release/github",
+        {
+          "successCommentCondition": false,
+          "failTitle": false
+        }
+      ]
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "npm",
+    "cdk",
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "prettier": "@bifravst/prettier-config",
+  "dependencies": {
+    "@aws-sdk/client-cloudformation": "3.1111.0",
+    "@aws-sdk/client-dynamodb": "3.1111.0",
+    "@aws-sdk/client-sts": "3.1111.0",
+    "@aws-cdk/toolkit-lib": "1.38.2",
+    "@aws-sdk/util-dynamodb": "3.996.9",
+    "@bifravst/aws-cdk-lambda-helpers": "5.0.4",
+    "@bifravst/cloudformation-helpers": "10.0.1",
+    "@bifravst/from-env": "4.0.0",
+    "@bifravst/run": "2.0.0",
+    "aws-cdk-lib": "2.265.0",
+    "cdk": "2.1136.0",
+    "chalk": "6.0.0",
+    "command-line-args": "6.0.2"
+  },
+  "devDependencies": {
+    "@bifravst/eslint-config-typescript": "8.0.0",
+    "@bifravst/prettier-config": "2.0.0",
+    "@commitlint/config-conventional": "21.2.2",
+    "@types/aws-lambda": "8.10.162",
+    "@types/command-line-args": "5.2.3",
+    "@types/node": "26.2.0",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "check-node-version": "4.2.1",
+    "commitlint": "21.2.2",
+    "husky": "9.1.7",
+    "lint-staged": "17.3.0",
+    "typescript": "npm:@typescript/typescript6@6.0.2"
+  }
+}

package/npm/src/mock.d.ts

@@ -0,0 +1,15 @@
+import type { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+type MockResponseFn = (methodPathQuery: string, response: Partial<{
+    headers: Headers;
+    status: number;
+    body: string;
+}>, keep?: boolean) => Promise<void>;
+export declare const mockResponse: (db: DynamoDBClient, responsesTable: string) => MockResponseFn;
+export type HttpAPIMock = {
+    response: MockResponseFn;
+};
+export declare const mock: ({ db, responsesTable, }: {
+    db: DynamoDBClient;
+    responsesTable: string;
+}) => HttpAPIMock;
+export {};

package/npm/src/mock.js

@@ -1,27 +1,31 @@
 import { registerResponse } from './responses.js';
-export const mockResponse = (db, responsesTable)=>async (methodPathQuery, response, keep)=>{
-        const [method, pathWithQuery] = methodPathQuery.split(' ', 2);
-        if (!/^[A-Z]+$/.test(method ?? '')) throw new Error(`Invalid method ${method} in ${methodPathQuery}!`);
-        if (pathWithQuery === undefined) throw new Error(`Missing path in ${methodPathQuery}!`);
-        const [path, query] = pathWithQuery.split('?', 2);
-        if (path.startsWith('/')) throw new Error(`Path ${path} must not start with /!`);
-        const bodyParts = [];
-        if (response.headers !== undefined) {
-            for (const [k, v] of response.headers.entries()){
-                bodyParts.push(`${k}: ${v}`);
-            }
-            bodyParts.push('');
+export const mockResponse = (db, responsesTable) => async (methodPathQuery, response, keep) => {
+    const [method, pathWithQuery] = methodPathQuery.split(' ', 2);
+    if (!/^[A-Z]+$/.test(method ?? ''))
+        throw new Error(`Invalid method ${method} in ${methodPathQuery}!`);
+    if (pathWithQuery === undefined)
+        throw new Error(`Missing path in ${methodPathQuery}!`);
+    const [path, query] = pathWithQuery.split('?', 2);
+    if (path.startsWith('/'))
+        throw new Error(`Path ${path} must not start with /!`);
+    const bodyParts = [];
+    if (response.headers !== undefined) {
+        for (const [k, v] of response.headers.entries()) {
+            bodyParts.push(`${k}: ${v}`);
         }
-        if (response.body !== undefined) bodyParts.push(response.body);
-        await registerResponse(db, responsesTable, {
-            path,
-            method: method ?? 'GET',
-            queryParams: new URLSearchParams(query),
-            body: bodyParts.length > 0 ? bodyParts.join('\n') : undefined,
-            statusCode: response.status,
-            keep
-        });
-    };
-export const mock = ({ db, responsesTable })=>({
-        response: mockResponse(db, responsesTable)
+        bodyParts.push('');
+    }
+    if (response.body !== undefined)
+        bodyParts.push(response.body);
+    await registerResponse(db, responsesTable, {
+        path,
+        method: method ?? 'GET',
+        queryParams: new URLSearchParams(query),
+        body: bodyParts.length > 0 ? bodyParts.join('\n') : undefined,
+        statusCode: response.status,
+        keep,
     });
+};
+export const mock = ({ db, responsesTable, }) => ({
+    response: mockResponse(db, responsesTable),
+});

package/npm/src/mock.spec.d.ts

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

package/npm/src/mock.spec.js

@@ -0,0 +1,36 @@
+import { unmarshall } from '@aws-sdk/util-dynamodb';
+import assert from 'node:assert/strict';
+import { describe, it, mock as testMock } from 'node:test';
+import { mock } from './mock.js';
+void describe('mock()', () => {
+    void it('should register a response', async () => {
+        const db = {
+            send: testMock.fn(async () => Promise.resolve(undefined)),
+        };
+        const httpApiMock = mock({
+            db: db,
+            responsesTable: 'response-table',
+        });
+        await httpApiMock.response(`GET foo/bar?k=v`, {
+            status: 200,
+            headers: new Headers({
+                'content-type': 'application/json; charset=utf-8',
+            }),
+            body: JSON.stringify({
+                result: 'some-value',
+            }),
+        });
+        assert.equal(db.send.mock.callCount(), 1);
+        const [{ input: args }] = db.send.mock.calls[0]?.arguments;
+        assert.equal(args.TableName, 'response-table');
+        const { methodPathQuery, statusCode, body, queryParams } = unmarshall(args.Item);
+        assert.equal(statusCode, 200);
+        assert.equal(methodPathQuery, 'GET foo/bar?k=v');
+        assert.equal(body, [
+            `content-type: application/json; charset=utf-8`,
+            ``,
+            JSON.stringify({ result: 'some-value' }),
+        ].join('\n'));
+        assert.deepEqual(queryParams, { k: 'v' });
+    });
+});

package/npm/src/parseMockRequest.d.ts

@@ -0,0 +1,7 @@
+export declare const parseMockRequest: (r: string) => {
+    method: string;
+    resource: string;
+    protocol: string;
+    headers: Record<string, string>;
+    body: string;
+};

package/npm/src/parseMockRequest.js

@@ -1,17 +1,19 @@
-export const parseMockRequest = (r)=>{
+export const parseMockRequest = (r) => {
     const lines = r.split('\n');
     const methodResourceProtol = lines.shift();
     const blankLineLocation = lines.indexOf('');
     const headerLines = blankLineLocation === -1 ? lines : lines.slice(0, blankLineLocation);
-    const body = blankLineLocation === -1 ? '' : lines.slice(blankLineLocation + 1).join('\n');
+    const body = blankLineLocation === -1
+        ? ''
+        : lines.slice(blankLineLocation + 1).join('\n');
     const requestInfo = /^(?<method>[A-Z]+) (?<resource>[^ ]+) (?<protocol>HTTP\/[0-9.]+)/.exec(methodResourceProtol ?? '')?.groups;
-    if (requestInfo === null) throw new Error(`Invalid request info: ${methodResourceProtol}`);
+    if (requestInfo === null)
+        throw new Error(`Invalid request info: ${methodResourceProtol}`);
     return {
         ...requestInfo,
-        headers: headerLines.map((s)=>s.split(':', 2)).reduce((headers, [k, v])=>({
-                ...headers,
-                [k ?? '']: v?.trim()
-            }), {}),
-        body
+        headers: headerLines
+            .map((s) => s.split(':', 2))
+            .reduce((headers, [k, v]) => ({ ...headers, [k ?? '']: v?.trim() }), {}),
+        body,
     };
 };

package/npm/src/parseMockRequest.spec.d.ts

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

package/npm/src/parseMockRequest.spec.js

@@ -0,0 +1,23 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { parseMockRequest } from './parseMockRequest.js';
+void describe('parseMockRequest()', () => {
+    void it('should parse method, resource, protocol, headers and body', () => assert.deepEqual(parseMockRequest([
+        `PATCH /v1/devices/foo/state HTTP/1.1`,
+        `Content-Length: 36`,
+        `Content-Type: application/json`,
+        `If-Match: 8835`,
+        ``,
+        `{"desired":{"config":{"nod":null}}}`,
+    ].join('\n')), {
+        method: 'PATCH',
+        resource: '/v1/devices/foo/state',
+        protocol: 'HTTP/1.1',
+        headers: {
+            'Content-Length': '36',
+            'Content-Type': 'application/json',
+            'If-Match': '8835',
+        },
+        body: '{"desired":{"config":{"nod":null}}}',
+    }));
+});

package/npm/src/parseMockResponse.d.ts

@@ -0,0 +1,6 @@
+export declare const parseMockResponse: (r: string) => {
+    statusCode: number;
+    protocol: string;
+    headers: Record<string, string>;
+    body: string;
+};

package/npm/src/parseMockResponse.js

@@ -1,18 +1,20 @@
-export const parseMockResponse = (r)=>{
+export const parseMockResponse = (r) => {
     const lines = r.split('\n');
     const protocolStatusCode = lines.shift();
     const blankLineLocation = lines.indexOf('');
     const headerLines = blankLineLocation === -1 ? lines : lines.slice(0, blankLineLocation);
-    const body = blankLineLocation === -1 ? '' : lines.slice(blankLineLocation + 1).join('\n');
+    const body = blankLineLocation === -1
+        ? ''
+        : lines.slice(blankLineLocation + 1).join('\n');
     const responseInfo = /^(?<protocol>HTTP\/[0-9.]+) (?<statusCode>[0-9]+) /.exec(protocolStatusCode ?? '')?.groups;
-    if (responseInfo === null) throw new Error(`Invalid request info: ${protocolStatusCode}`);
+    if (responseInfo === null)
+        throw new Error(`Invalid request info: ${protocolStatusCode}`);
     return {
         statusCode: parseInt(responseInfo.statusCode, 10),
         protocol: responseInfo.protocol,
-        headers: headerLines.map((s)=>s.split(':', 2)).reduce((headers, [k, v])=>({
-                ...headers,
-                [k ?? '']: v?.trim()
-            }), {}),
-        body
+        headers: headerLines
+            .map((s) => s.split(':', 2))
+            .reduce((headers, [k, v]) => ({ ...headers, [k ?? '']: v?.trim() }), {}),
+        body,
     };
 };

package/npm/src/parseMockResponse.spec.d.ts

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

package/npm/src/parseMockResponse.spec.js

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { parseMockResponse } from './parseMockResponse.js';
+void describe('parseMockResponse()', () => {
+    void it('should parse protocol, statusCode, headers and body', () => assert.deepEqual(parseMockResponse([
+        `HTTP/1.1 202 Accepted`,
+        `Content-Length: 36`,
+        `Content-Type: application/json`,
+        ``,
+        `{"desired":{"config":{"nod":null}}}`,
+    ].join('\n')), {
+        statusCode: 202,
+        protocol: 'HTTP/1.1',
+        headers: {
+            'Content-Length': '36',
+            'Content-Type': 'application/json',
+        },
+        body: '{"desired":{"config":{"nod":null}}}',
+    }));
+});

package/npm/src/randomString.d.ts

@@ -0,0 +1 @@
+export declare const randomString: () => string;

package/npm/src/randomString.js

@@ -1,2 +1,5 @@
 import crypto from 'node:crypto';
-export const randomString = ()=>crypto.randomBytes(Math.ceil(8 * 0.5)).toString('hex').slice(0, 8);
+export const randomString = () => crypto
+    .randomBytes(Math.ceil(8 * 0.5))
+    .toString('hex')
+    .slice(0, 8);

package/npm/src/requests.d.ts

@@ -0,0 +1,13 @@
+import { type DynamoDBClient } from '@aws-sdk/client-dynamodb';
+export type Request = {
+    path: string;
+    query: null;
+    timestamp: string;
+    ttl: string;
+    headers: Record<string, string>;
+    method: string;
+    requestId: string;
+    body: string;
+    methodPathQuery: string;
+};
+export declare const listRequests: (db: DynamoDBClient, requestsTable: string) => Promise<Array<Request>>;

package/npm/src/requests.js

@@ -1,11 +1,11 @@
 import { ScanCommand } from '@aws-sdk/client-dynamodb';
 import { unmarshall } from '@aws-sdk/util-dynamodb';
-export const listRequests = async (db, requestsTable)=>((await db.send(new ScanCommand({
-        TableName: requestsTable
-    }))).Items ?? []).map((item)=>{
-        const i = unmarshall(item);
-        return {
-            ...i,
-            headers: JSON.parse(i.headers)
-        };
-    }).sort((i1, i2)=>i1.timestamp.localeCompare(i2.timestamp));
+export const listRequests = async (db, requestsTable) => ((await db.send(new ScanCommand({ TableName: requestsTable }))).Items ?? [])
+    .map((item) => {
+    const i = unmarshall(item);
+    return {
+        ...i,
+        headers: JSON.parse(i.headers),
+    };
+})
+    .sort((i1, i2) => i1.timestamp.localeCompare(i2.timestamp));

package/npm/src/responses.d.ts

@@ -0,0 +1,16 @@
+import { type DynamoDBClient } from '@aws-sdk/client-dynamodb';
+export type Response = {
+    method: string;
+    path: string;
+    queryParams?: URLSearchParams;
+    statusCode?: number;
+    /**
+     * Header + Body
+     *
+     * @see splitMockResponse
+     */
+    body?: string;
+    ttl?: number;
+    keep?: boolean;
+};
+export declare const registerResponse: (db: DynamoDBClient, responsesTable: string, response: Response) => Promise<void>;

package/npm/src/responses.js

@@ -2,7 +2,7 @@ import { PutItemCommand } from '@aws-sdk/client-dynamodb';
 import { marshall } from '@aws-sdk/util-dynamodb';
 import { randomUUID } from 'node:crypto';
 import { sortQuery } from './sortQueryString.js';
-export const registerResponse = async (db, responsesTable, response)=>{
+export const registerResponse = async (db, responsesTable, response) => {
     await db.send(new PutItemCommand({
         TableName: responsesTable,
         Item: marshall({
@@ -11,11 +11,11 @@ export const registerResponse = async (db, responsesTable, response)=>{
             timestamp: new Date().toISOString(),
             statusCode: response.statusCode,
             body: response.body,
-            queryParams: response.queryParams !== undefined ? Object.fromEntries(response.queryParams) : undefined,
+            queryParams: response.queryParams !== undefined
+                ? Object.fromEntries(response.queryParams)
+                : undefined,
             ttl: response.ttl,
-            keep: response.keep
-        }, {
-            removeUndefinedValues: true
-        })
+            keep: response.keep,
+        }, { removeUndefinedValues: true }),
     }));
 };

package/npm/src/sortQueryString.d.ts

@@ -0,0 +1,3 @@
+import { URLSearchParams } from 'node:url';
+export declare const sortQueryString: (mockUrl: string) => string;
+export declare const sortQuery: (query: URLSearchParams | Record<string, string>) => string;

package/npm/src/sortQueryString.js

@@ -1,24 +1,23 @@
 import { URLSearchParams } from 'node:url';
-export const sortQueryString = (mockUrl)=>{
+export const sortQueryString = (mockUrl) => {
     const [host, query] = mockUrl.split('?', 2);
-    if (query === undefined || (query?.length ?? 0) === 0) return host;
+    if (query === undefined || (query?.length ?? 0) === 0)
+        return host;
     return `${host}?${sortQuery(new URLSearchParams(query))}`;
 };
-export const sortQuery = (query)=>{
+export const sortQuery = (query) => {
     const params = [];
     if (query instanceof URLSearchParams) {
-        query.forEach((v, k)=>{
-            params.push([
-                k,
-                v
-            ]);
+        query.forEach((v, k) => {
+            params.push([k, v]);
         });
-    } else {
+    }
+    else {
         params.push(...Object.entries(query));
     }
-    params.sort(([k1], [k2])=>(k1 ?? '').localeCompare(k2 ?? ''));
+    params.sort(([k1], [k2]) => (k1 ?? '').localeCompare(k2 ?? ''));
     const sortedParams = new URLSearchParams();
-    for (const [k, v] of params){
+    for (const [k, v] of params) {
         sortedParams.append(k, v);
     }
     return sortedParams.toString();

package/npm/src/sortQueryString.spec.d.ts

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

package/npm/src/sortQueryString.spec.js

@@ -0,0 +1,18 @@
+import assert from 'node:assert';
+import { describe, test as it } from 'node:test';
+import { URLSearchParams } from 'node:url';
+import { sortQuery, sortQueryString } from './sortQueryString.js';
+void describe('sortQueryString', () => {
+    void it('should sort the query part of a mock URL', () => assert.deepStrictEqual(sortQueryString('api.nrfcloud.com/v1/location/agps?eci=73393515&tac=132&requestType=custom&mcc=397&mnc=73&customTypes=2'), 'api.nrfcloud.com/v1/location/agps?customTypes=2&eci=73393515&mcc=397&mnc=73&requestType=custom&tac=132'));
+});
+void describe('sortQuery', () => {
+    void it('should sort URLSearchParams', () => assert.equal(sortQuery(new URLSearchParams('eci=73393515&tac=132&requestType=custom&mcc=397&mnc=73&customTypes=2')), 'customTypes=2&eci=73393515&mcc=397&mnc=73&requestType=custom&tac=132'));
+    void it('should sort a Record', () => assert.equal(sortQuery({
+        eci: '73393515',
+        tac: '132',
+        requestType: 'custom',
+        mcc: '397',
+        mnc: '73',
+        customTypes: '2',
+    }), 'customTypes=2&eci=73393515&mcc=397&mnc=73&requestType=custom&tac=132'));
+});

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@bifravst/http-api-mock",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "description": "Helper functions for AWS lambdas written in TypeScript.",
   "exports": {
     "./*": {
       "import": {
         "default": "./npm/src/*.js",
-        "types": "./src/*.ts"
+        "types": "./npm/src/*.d.ts"
       }
     }
   },
   "type": "module",
   "scripts": {
     "prepare": "husky && case \"$npm_command\" in install|ci) check-node-version --package ;; esac",
-    "prepublishOnly": "node --no-warnings --experimental-transform-types  ./.npm/compile.ts && cp -rv cdk/* npm/cdk",
+    "prepublishOnly": "npx tsc --noEmit false --outDir ./npm -d && cp -rv cdk/* npm/cdk && cp package.json npm/package.json",
     "test": "node --no-warnings --experimental-transform-types --test \"!(node_modules|e2e-tests|integration-tests)/**/*.spec.ts\""
   },
   "repository": {
@@ -79,18 +79,18 @@
     "@aws-sdk/client-sts": "3.1111.0",
     "@aws-cdk/toolkit-lib": "1.38.2",
     "@aws-sdk/util-dynamodb": "3.996.9",
-    "@bifravst/aws-cdk-lambda-helpers": "4.0.96",
-    "@bifravst/cloudformation-helpers": "9.1.1",
-    "@bifravst/from-env": "3.0.2",
-    "@bifravst/run": "1.2.0",
+    "@bifravst/aws-cdk-lambda-helpers": "5.0.4",
+    "@bifravst/cloudformation-helpers": "10.0.1",
+    "@bifravst/from-env": "4.0.0",
+    "@bifravst/run": "2.0.0",
     "aws-cdk-lib": "2.265.0",
     "cdk": "2.1136.0",
     "chalk": "6.0.0",
     "command-line-args": "6.0.2"
   },
   "devDependencies": {
-    "@bifravst/eslint-config-typescript": "7.0.34",
-    "@bifravst/prettier-config": "1.1.17",
+    "@bifravst/eslint-config-typescript": "8.0.0",
+    "@bifravst/prettier-config": "2.0.0",
     "@commitlint/config-conventional": "21.2.2",
     "@types/aws-lambda": "8.10.162",
     "@types/command-line-args": "5.2.3",