@bifravst/http-api-mock 2.1.354 → 2.1.356

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

@@ -1,147 +0,0 @@
-import {
-	DeleteItemCommand,
-	DynamoDBClient,
-	PutItemCommand,
-	ScanCommand,
-} from '@aws-sdk/client-dynamodb'
-import { marshall, unmarshall } from '@aws-sdk/util-dynamodb'
-import type {
-	APIGatewayEvent,
-	APIGatewayProxyResult,
-	Context,
-} from 'aws-lambda'
-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: APIGatewayEvent,
-	context: Context,
-): Promise<APIGatewayProxyResult> => {
-	console.log(JSON.stringify({ event }))
-	const query =
-		event.queryStringParameters !== null &&
-		event.queryStringParameters !== undefined
-			? new URLSearchParams(
-					event.queryStringParameters as Record<string, string>,
-				)
-			: undefined
-	const path = event.path.replace(/^\//, '')
-	const pathWithQuery = sortQueryString(
-		`${path}${query !== undefined ? `?${query.toString()}` : ''}`,
-	)
-
-	const request = {
-		methodPathQuery: `${event.httpMethod} ${pathWithQuery}`,
-		timestamp: new Date().toISOString(),
-		requestId: context.awsRequestId,
-		method: event.httpMethod,
-		path,
-		query: query === undefined ? null : Object.fromEntries(query),
-		body: event.body ?? '{}',
-		headers: JSON.stringify(event.headers),
-	}
-
-	// Check if response exists
-	console.debug(
-		`Checking if response exists for ${event.httpMethod} ${pathWithQuery}...`,
-	)
-	// Scan using httpMethod and path only so query strings can be partially matched
-	const { Items } = await db.send(
-		new ScanCommand({
-			TableName: process.env.RESPONSES_TABLE_NAME,
-			FilterExpression: 'begins_with(methodPathQuery, :methodPath)',
-			ExpressionAttributeValues: {
-				[':methodPath']: {
-					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))
-
-	let res: APIGatewayProxyResult = {
-		statusCode: 404,
-		body: 'No responses found',
-	}
-	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
-		) {
-			await db.send(
-				new DeleteItemCommand({
-					TableName: process.env.RESPONSES_TABLE_NAME,
-					Key: marshall({
-						requestId: objItem.requestId,
-						timestamp: objItem.timestamp,
-					}),
-				}),
-			)
-		}
-
-		const { body, headers } = splitMockResponse(objItem.body ?? '')
-
-		// Send as binary, if mock response is HEX encoded. See https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html
-		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,
-		}
-
-		break
-	}
-
-	console.debug(`Return response`, JSON.stringify({ response: res }))
-
-	await db.send(
-		new PutItemCommand({
-			TableName: process.env.REQUESTS_TABLE_NAME,
-			Item: marshall(
-				{
-					...request,
-					responseStatusCode: res.statusCode,
-					responseHeaders: res.headers,
-					responseBody: res.body,
-					responseIsBase64Encoded: res.isBase64Encoded,
-				},
-				{
-					removeUndefinedValues: true,
-				},
-			),
-		}),
-	)
-
-	return res
-}

package/cdk/resources/splitMockResponse.spec.ts

@@ -1,17 +0,0 @@
-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/cdk/resources/splitMockResponse.ts

@@ -1,25 +0,0 @@
-export const splitMockResponse = (
-	r: string,
-): { headers: Record<string, string>; body: string } => {
-	const trimmedLines = r
-		.split('\n')
-		.map((s) => s.trim())
-		.join('\n')
-	const blankLineLocation = trimmedLines.indexOf('\n\n')
-	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 as string]: v?.trim() }),
-				{},
-			),
-		body: trimmedLines.slice(blankLineLocation + 2),
-	}
-}

package/cli.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-import { cli } from './dist/src/cli.js'
-
-await cli()

package/dist/cdk/App.d.ts

@@ -1,11 +0,0 @@
-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/dist/cdk/App.js

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

package/dist/cdk/Stack.d.ts

@@ -1,20 +0,0 @@
-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/dist/cdk/Stack.js

@@ -1,40 +0,0 @@
-import { LambdaSource } from '@bifravst/aws-cdk-lambda-helpers/cdk';
-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, }) {
-        super(parent, stackName, {
-            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,
-            }).code,
-            compatibleArchitectures: [Lambda.Architecture.ARM_64],
-            compatibleRuntimes: [Lambda.Runtime.NODEJS_22_X],
-        });
-        const httpMockApi = new HttpApiMock(this, {
-            lambdaSources,
-            layers: [baseLayer],
-        });
-        // Export these so the test runner can use them
-        new CfnOutput(this, 'apiURL', {
-            value: httpMockApi.api.url,
-            exportName: `${this.stackName}:apiURL`,
-        });
-        new CfnOutput(this, 'responsesTableName', {
-            value: httpMockApi.responsesTable.tableName,
-            exportName: `${this.stackName}:responsesTableName`,
-        });
-        new CfnOutput(this, 'requestsTableName', {
-            value: httpMockApi.requestsTable.tableName,
-            exportName: `${this.stackName}:requestsTableName`,
-        });
-    }
-}

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

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

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

@@ -1,35 +0,0 @@
-import { packLambdaFromPath } from '@bifravst/aws-cdk-lambda-helpers';
-import { packLayer } from '@bifravst/aws-cdk-lambda-helpers/layer';
-import { fromEnv } from '@bifravst/from-env';
-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' assert { type: 'json' };
-import { HTTPAPIMockApp } from './App.js';
-const { stackName } = fromEnv({ stackName: 'HTTP_API_MOCK_STACK_NAME' })(process.env);
-const baseDir = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
-const distDir = await fs.mkdtemp(path.join(os.tmpdir(), 'temp-'));
-const lambdasDir = path.join(distDir, 'lambdas');
-await fs.mkdir(lambdasDir);
-const layersDir = path.join(distDir, 'layers');
-await fs.mkdir(layersDir);
-const dependencies = [
-    '@bifravst/from-env',
-];
-new HTTPAPIMockApp(stackName, {
-    lambdaSources: {
-        httpApiMock: await packLambdaFromPath({
-            id: 'httpApiMock',
-            sourceFilePath: 'cdk/resources/http-api-mock-lambda.ts',
-            baseDir,
-            distDir: lambdasDir,
-        }),
-    },
-    layer: await packLayer({
-        id: 'testResources',
-        dependencies,
-        baseDir,
-        distDir: layersDir,
-    }),
-});

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

@@ -1,14 +0,0 @@
-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/dist/cdk/resources/HttpApiMock.js

@@ -1,87 +0,0 @@
-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, }) {
-        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,
-            },
-            sortKey: {
-                name: 'timestamp',
-                type: DynamoDB.AttributeType.STRING,
-            },
-            pointInTimeRecovery: true,
-            removalPolicy: RemovalPolicy.DESTROY,
-        });
-        this.requestsTable.addGlobalSecondaryIndex({
-            indexName: 'methodPathQuery',
-            partitionKey: {
-                name: 'methodPathQuery',
-                type: DynamoDB.AttributeType.STRING,
-            },
-            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,
-            },
-            sortKey: {
-                name: 'timestamp',
-                type: DynamoDB.AttributeType.STRING,
-            },
-            pointInTimeRecovery: true,
-            removalPolicy: RemovalPolicy.DESTROY,
-            timeToLiveAttribute: 'ttl',
-        });
-        this.responsesTable.addGlobalSecondaryIndex({
-            indexName: 'methodPathQuery',
-            partitionKey: {
-                name: 'methodPathQuery',
-                type: DynamoDB.AttributeType.STRING,
-            },
-            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', {
-            description: 'Mocks a HTTP API and stores all requests in SQS for inspection, and optionally replies with enqued responses',
-            code: new LambdaSource(this, lambdaSources.httpApiMock).code,
-            layers,
-            handler: lambdaSources.httpApiMock.handler,
-            architecture: Lambda.Architecture.ARM_64,
-            runtime: Lambda.Runtime.NODEJS_22_X,
-            timeout: Duration.seconds(5),
-            environment: {
-                REQUESTS_TABLE_NAME: this.requestsTable.tableName,
-                RESPONSES_TABLE_NAME: this.responsesTable.tableName,
-                LOG_LEVEL: this.node.tryGetContext('logLevel'),
-                NODE_NO_WARNINGS: '1',
-            },
-            ...new LambdaLogGroup(this, 'LambdaLogs', Logs.RetentionDays.ONE_DAY),
-        });
-        this.responsesTable.grantReadWriteData(lambda);
-        this.requestsTable.grantReadWriteData(lambda);
-        // This is the API Gateway, AWS CDK automatically creates a prod stage and deployment
-        this.api = new ApiGateway.RestApi(this, 'api', {
-            restApiName: `HTTP Mock API for testing`,
-            description: 'API Gateway to test outgoing requests',
-            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(),
-        });
-    }
-}

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

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

package/dist/cdk/resources/checkMatchingQueryParams.js

@@ -1,33 +0,0 @@
-const matchRegex = /^\/(?<re>.+)\/(?<option>[gi])?$/;
-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) {
-        const expectedValue = expected[prop];
-        const actualValue = actual?.[prop];
-        if (actualValue === undefined)
-            return false;
-        if (typeof expectedValue === 'string') {
-            const match = matchRegex.exec(expectedValue);
-            if (match !== null) {
-                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;
-            }
-        }
-        else {
-            // All query parameters are string
-            if (actualValue !== String(expectedValue))
-                return false;
-        }
-    }
-    return true;
-};

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

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

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

@@ -1,57 +0,0 @@
-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/dist/cdk/resources/http-api-mock-lambda.d.ts

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

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

@@ -1,98 +0,0 @@
-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;
-    const path = event.path.replace(/^\//, '');
-    const pathWithQuery = sortQueryString(`${path}${query !== undefined ? `?${query.toString()}` : ''}`);
-    const request = {
-        methodPathQuery: `${event.httpMethod} ${pathWithQuery}`,
-        timestamp: new Date().toISOString(),
-        requestId: context.awsRequestId,
-        method: event.httpMethod,
-        path,
-        query: query === undefined ? null : Object.fromEntries(query),
-        body: event.body ?? '{}',
-        headers: JSON.stringify(event.headers),
-    };
-    // Check if response exists
-    console.debug(`Checking if response exists for ${event.httpMethod} ${pathWithQuery}...`);
-    // Scan using httpMethod and path only so query strings can be partially matched
-    const { Items } = await db.send(new ScanCommand({
-        TableName: process.env.RESPONSES_TABLE_NAME,
-        FilterExpression: 'begins_with(methodPathQuery, :methodPath)',
-        ExpressionAttributeValues: {
-            [':methodPath']: {
-                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));
-    let res = {
-        statusCode: 404,
-        body: 'No responses found',
-    };
-    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) {
-            await db.send(new DeleteItemCommand({
-                TableName: process.env.RESPONSES_TABLE_NAME,
-                Key: marshall({
-                    requestId: objItem.requestId,
-                    timestamp: objItem.timestamp,
-                }),
-            }));
-        }
-        const { body, headers } = splitMockResponse(objItem.body ?? '');
-        // Send as binary, if mock response is HEX encoded. See https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html
-        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,
-        };
-        break;
-    }
-    console.debug(`Return response`, JSON.stringify({ response: res }));
-    await db.send(new PutItemCommand({
-        TableName: process.env.REQUESTS_TABLE_NAME,
-        Item: marshall({
-            ...request,
-            responseStatusCode: res.statusCode,
-            responseHeaders: res.headers,
-            responseBody: res.body,
-            responseIsBase64Encoded: res.isBase64Encoded,
-        }, {
-            removeUndefinedValues: true,
-        }),
-    }));
-    return res;
-};

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

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

package/dist/cdk/resources/splitMockResponse.js

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

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

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