@bifravst/http-api-mock 2.1.353 → 2.1.355

package/npm/mock.js

@@ -0,0 +1,27 @@
+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('');
+        }
+        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/parseMockRequest.js

@@ -0,0 +1,17 @@
+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 requestInfo = /^(?<method>[A-Z]+) (?<resource>[^ ]+) (?<protocol>HTTP\/[0-9.]+)/.exec(methodResourceProtol ?? '')?.groups;
+    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
+    };
+};

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

@@ -1,20 +1,18 @@
-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/randomString.js

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

package/{dist/src → npm}/requests.d.ts

@@ -10,4 +10,4 @@ export type Request = {
     body: string;
     methodPathQuery: string;
 };
-export declare const listRequests: (db: DynamoDBClient, requestsTable: string) => Promise<Array<Request>>;
+export declare const listRequests: (db: DynamoDBClient, requestsTable: string) => Promise<Request[]>;

package/npm/requests.js

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

package/{dist/src → npm}/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/{dist/src → npm}/sortQueryString.d.ts

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

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

@@ -1,23 +1,24 @@
 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/package.json

@@ -1,23 +1,20 @@
 {
   "name": "@bifravst/http-api-mock",
-  "version": "2.1.353",
+  "version": "2.1.355",
   "description": "Helper functions for AWS lambdas written in TypeScript.",
   "exports": {
     "./*": {
       "import": {
-        "types": "./dist/src/*.d.ts",
-        "default": "./dist/src/*.js"
+        "types": "./npm/*.d.ts",
+        "default": "./npm/*.js"
       }
     }
   },
   "type": "module",
   "scripts": {
     "prepare": "husky",
-    "prepublishOnly": "npx tsc --noEmit false --outDir ./dist -d",
-    "test": "npx globstar -- npx tsx --test --test-reporter spec \"!(dist|node_modules)/**/*.spec.ts\""
-  },
-  "bin": {
-    "http-api-mock": "cli.js"
+    "prepublishOnly": "node --experimental-strip-types ./.npm/compile.ts && npx tsgo src/*.ts --emitDeclarationOnly --declaration --ignoreConfig --allowImportingTsExtensions --target esnext --module nodenext --moduleResolution nodenext --outDir ./npm && mv npm/src/* npm",
+    "test": "node --no-warnings --experimental-transform-types --test \"!(node_modules|e2e-tests|integration-tests)/**/*.spec.ts\""
   },
   "repository": {
     "type": "git",
@@ -44,8 +41,8 @@
     ]
   },
   "engines": {
-    "node": ">=22",
-    "npm": ">=10"
+    "node": ">=24",
+    "npm": ">=11"
   },
   "release": {
     "branches": [
@@ -69,37 +66,36 @@
     "access": "public"
   },
   "files": [
-    "dist/cdk",
-    "dist/src",
-    "cdk",
-    "src",
-    "cli.js",
+    "npm",
     "LICENSE",
     "README.md"
   ],
   "prettier": "@bifravst/prettier-config",
   "dependencies": {
-    "@aws-sdk/client-cloudformation": "3.946.0",
-    "@aws-sdk/client-dynamodb": "3.946.0",
-    "@aws-sdk/client-sts": "3.946.0",
-    "@aws-sdk/util-dynamodb": "3.946.0",
-    "@bifravst/aws-cdk-lambda-helpers": "2.3.10",
+    "@aws-sdk/client-cloudformation": "3.972.0",
+    "@aws-sdk/client-dynamodb": "3.972.0",
+    "@aws-sdk/client-sts": "3.972.0",
+    "@aws-sdk/util-dynamodb": "3.972.0",
+    "@bifravst/aws-cdk-lambda-helpers": "4.0.12",
     "@bifravst/cloudformation-helpers": "9.1.1",
     "@bifravst/from-env": "3.0.2",
     "@bifravst/run": "1.2.0",
-    "aws-cdk-lib": "2.232.0",
-    "cdk": "2.1033.0",
+    "aws-cdk-lib": "2.235.1",
+    "cdk": "2.1101.0",
     "chalk": "5.6.2",
     "tsx": "4.21.0"
   },
   "devDependencies": {
+    "@aws-cdk/toolkit-lib": "1.13.0",
     "@bifravst/eslint-config-typescript": "6.4.4",
     "@bifravst/prettier-config": "1.1.17",
-    "@commitlint/config-conventional": "19.8.1",
-    "@types/aws-lambda": "8.10.159",
-    "@types/node": "22.19.1",
-    "commitlint": "19.8.1",
-    "globstar": "1.0.0",
+    "@commitlint/config-conventional": "20.3.1",
+    "@types/aws-lambda": "8.10.160",
+    "@types/command-line-args": "5.2.3",
+    "@types/node": "25.0.9",
+    "@typescript/native-preview": "7.0.0-dev.20260120.1",
+    "command-line-args": "6.0.1",
+    "commitlint": "20.3.1",
     "husky": "9.1.7"
   }
 }

package/cdk/App.ts

@@ -1,26 +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'
-import { HTTPAPIMockStack } from './Stack.js'
-
-export class HTTPAPIMockApp extends App {
-	public constructor(
-		stackName: string,
-		{
-			lambdaSources,
-			layer,
-		}: {
-			lambdaSources: {
-				httpApiMock: PackedLambda
-			}
-			layer: PackedLayer
-		},
-	) {
-		super({
-			context: {
-				isTest: true,
-			},
-		})
-		new HTTPAPIMockStack(this, stackName, { lambdaSources, layer })
-	}
-}

package/cdk/Stack.ts

@@ -1,66 +0,0 @@
-import type { PackedLambda } from '@bifravst/aws-cdk-lambda-helpers'
-import { LambdaSource } from '@bifravst/aws-cdk-lambda-helpers/cdk'
-import type { PackedLayer } from '@bifravst/aws-cdk-lambda-helpers/layer'
-import type { App } from 'aws-cdk-lib'
-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 {
-	public constructor(
-		parent: App,
-		stackName: string,
-		{
-			lambdaSources,
-			layer,
-		}: {
-			lambdaSources: {
-				httpApiMock: PackedLambda
-			}
-			layer: PackedLayer
-		},
-	) {
-		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`,
-		})
-	}
-}
-
-export type StackOutputs = {
-	apiURL: string
-	requestsTableName: string
-	responsesTableName: string
-}

package/cdk/http-api-mock.ts

@@ -1,41 +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: Array<keyof (typeof pJSON)['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/cdk/resources/HttpApiMock.ts

@@ -1,119 +0,0 @@
-import type { PackedLambda } from '@bifravst/aws-cdk-lambda-helpers'
-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 type { Construct } from 'constructs'
-
-export class HttpApiMock extends Resource {
-	public readonly api: ApiGateway.RestApi
-	public readonly requestsTable: DynamoDB.Table
-	public readonly responsesTable: DynamoDB.Table
-
-	public constructor(
-		parent: Construct,
-		{
-			lambdaSources,
-			layers,
-		}: {
-			lambdaSources: {
-				httpApiMock: PackedLambda
-			}
-			layers: Lambda.ILayerVersion[]
-		},
-	) {
-		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/cdk/resources/checkMatchingQueryParams.spec.ts

@@ -1,67 +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/cdk/resources/checkMatchingQueryParams.ts

@@ -1,40 +0,0 @@
-type Logger = {
-	debug: (...arg: any) => void
-}
-const matchRegex = /^\/(?<re>.+)\/(?<option>[gi])?$/
-
-export const checkMatchingQueryParams = (
-	actual: Record<string, unknown> | null,
-	expected: Record<string, unknown>,
-	log?: Logger,
-): boolean => {
-	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
-}