@geekmidas/constructs 3.0.2 → 3.0.5

package/src/endpoints/AmazonApiGatewayV1EndpointAdaptor.ts

@@ -59,7 +59,11 @@ export class AmazonApiGatewayV1Endpoint<
 		}
 
 		return {
-			body: e.body ? JSON.parse(e.body) : undefined,
+			body: AmazonApiGatewayEndpoint.decodeBody(
+				e.body,
+				e.isBase64Encoded,
+				e.headers?.['Content-Type'] ?? e.headers?.['content-type'],
+			),
 			query: parseQueryParams(mergedParams),
 			params: e.pathParameters || {},
 		};

package/src/endpoints/AmazonApiGatewayV2EndpointAdaptor.ts

@@ -4,6 +4,7 @@ import type { Logger } from '@geekmidas/logger';
 import type { Service } from '@geekmidas/services';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { APIGatewayProxyEventV2, Context } from 'aws-lambda';
+import qs from 'qs';
 import type { HttpMethod } from '../types';
 import {
 	AmazonApiGatewayEndpoint,
@@ -14,7 +15,6 @@ import {
 } from './AmazonApiGatewayEndpointAdaptor';
 import type { CookieFn, Endpoint, EndpointSchemas } from './Endpoint';
 import { createApiGatewayCookies } from './lazyAccessors';
-import { parseQueryParams } from './parseQueryParams';
 
 export class AmazonApiGatewayV2Endpoint<
 	TRoute extends string,
@@ -45,25 +45,15 @@ export class AmazonApiGatewayV2Endpoint<
 	}
 
 	override getInput(e: APIGatewayProxyEventV2): GetInputResponse {
-		// API Gateway V2 handles arrays as comma-separated values
-		const queryParams = e.queryStringParameters || {};
-		const processedParams: Record<string, string | string[]> = {};
-
-		for (const [key, value] of Object.entries(queryParams)) {
-			if (value !== undefined) {
-				// Check if value contains comma and could be an array
-				// Be careful not to split values that legitimately contain commas
-				if (value.includes(',') && !value.includes('"')) {
-					processedParams[key] = value.split(',').map((v) => v.trim());
-				} else {
-					processedParams[key] = value;
-				}
-			}
-		}
+		const raw = AmazonApiGatewayEndpoint.decodeBody(
+			e.body,
+			e.isBase64Encoded,
+			e.headers?.['content-type'],
+		);
 
 		return {
-			body: e.body ? JSON.parse(e.body) : undefined,
-			query: parseQueryParams(processedParams),
+			body: raw,
+			query: qs.parse(e.rawQueryString) as Record<string, any>,
 			params: e.pathParameters || {},
 		};
 	}

package/src/endpoints/Endpoint.ts

@@ -113,7 +113,8 @@ export class Endpoint<
 	public getSession: SessionFn<TServices, TLogger, TSession, TDatabase> = () =>
 		({}) as TSession;
 	/** Function to determine if the request is authorized */
-	public authorize: AuthorizeFn<TServices, TLogger, TSession> = () => true;
+	public authorize: AuthorizeFn<TServices, TLogger, TSession, TInput> = () =>
+		true;
 	/** Optional rate limiting configuration */
 	public rateLimit?: RateLimitConfig;
 	/** Optional authorizer for this endpoint */
@@ -749,7 +750,7 @@ export interface EndpointOptions<
 		TAuditAction
 	>;
 	/** Optional authorization check function */
-	authorize: AuthorizeFn<TServices, TLogger, TSession> | undefined;
+	authorize: AuthorizeFn<TServices, TLogger, TSession, TInput> | undefined;
 	/** Optional description for documentation */
 	description: string | undefined;
 	/** Optional tags for OpenAPI documentation */
@@ -813,13 +814,14 @@ export type AuthorizeContext<
 	TServices extends Service[] = [],
 	TLogger extends Logger = Logger,
 	TSession = unknown,
+	TInput extends EndpointSchemas | undefined = undefined,
 > = {
 	services: ServiceRecord<TServices>;
 	logger: TLogger;
 	header: HeaderFn;
 	cookie: CookieFn;
 	session: TSession;
-};
+} & InferComposableStandardSchema<TInput>;
 /**
  * Function type for endpoint authorization checks.
  *
@@ -841,8 +843,9 @@ export type AuthorizeFn<
 	TServices extends Service[] = [],
 	TLogger extends Logger = Logger,
 	TSession = unknown,
+	TInput extends EndpointSchemas | undefined = undefined,
 > = (
-	ctx: AuthorizeContext<TServices, TLogger, TSession>,
+	ctx: AuthorizeContext<TServices, TLogger, TSession, TInput>,
 ) => Promise<boolean> | boolean;
 
 /**

package/src/endpoints/EndpointBuilder.ts

@@ -63,7 +63,7 @@ export class EndpointBuilder<
 	protected _memorySize?: number;
 	_getSession: SessionFn<TServices, TLogger, TSession, TDatabase> = () =>
 		({}) as TSession;
-	_authorize: AuthorizeFn<TServices, TLogger, TSession> = () => true;
+	_authorize: AuthorizeFn<TServices, TLogger, TSession, TInput> = () => true;
 	_rateLimit?: RateLimitConfig;
 	_availableAuthorizers: Authorizer[] = [];
 	_authorizerName?: TAuthorizers[number];
@@ -263,6 +263,11 @@ export class EndpointBuilder<
 		return this;
 	}
 
+	authorize(fn: AuthorizeFn<TServices, TLogger, TSession, TInput>): this {
+		this._authorize = fn;
+		return this;
+	}
+
 	rateLimit(config: RateLimitConfig): this {
 		this._rateLimit = config;
 		return this;

package/src/endpoints/EndpointFactory.ts

@@ -988,7 +988,7 @@ export class EndpointFactory<
 		>(fullPath, method);
 
 		if (this.defaultAuthorizeFn) {
-			builder._authorize = this.defaultAuthorizeFn;
+			builder._authorize = this.defaultAuthorizeFn as any;
 		}
 		if (this.defaultServices.length) {
 			// Create a copy to avoid sharing references between builders

package/src/endpoints/HonoEndpointAdaptor.ts

@@ -393,6 +393,15 @@ export class HonoEndpoint<
 							services,
 							logger,
 							session,
+							body: features.hasBodyValidation
+								? (c.req.valid as any)('json')
+								: undefined,
+							query: features.hasQueryValidation
+								? (c.req.valid as any)('query')
+								: undefined,
+							params: features.hasParamValidation
+								? (c.req.valid as any)('param')
+								: undefined,
 						});
 
 						if (!isAuthorized) {

package/src/endpoints/TestEndpointAdaptor.ts

@@ -216,6 +216,9 @@ export class TestEndpointAdaptor<
 				services: ctx.services,
 				logger,
 				session,
+				body,
+				query,
+				params,
 			});
 
 			if (!isAuthorized) {

package/src/endpoints/__tests__/AmazonApiGatewayV1EndpointAdaptor.spec.ts

@@ -45,6 +45,118 @@ describe('AmazonApiGatewayV1Endpoint', () => {
 		envParser = new EnvironmentParser({});
 	});
 
+	describe('getInput', () => {
+		it('should parse JSON body when content-type is application/json', () => {
+			const endpoint = new Endpoint({
+				route: '/test',
+				method: 'GET',
+				fn: async () => ({ success: true }),
+				input: {},
+				output: z.object({ success: z.boolean() }),
+				services: [],
+				logger: mockLogger,
+				timeout: undefined,
+				memorySize: undefined,
+				status: undefined,
+				getSession: undefined,
+				authorize: undefined,
+				description: 'Test endpoint',
+			});
+			const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+
+			const event = createMockV1Event({
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ name: 'test' }),
+			});
+
+			const result = adapter.getInput(event);
+			expect(result.body).toEqual({ name: 'test' });
+		});
+
+		it('should decode base64-encoded JSON body', () => {
+			const endpoint = new Endpoint({
+				route: '/test',
+				method: 'GET',
+				fn: async () => ({ success: true }),
+				input: {},
+				output: z.object({ success: z.boolean() }),
+				services: [],
+				logger: mockLogger,
+				timeout: undefined,
+				memorySize: undefined,
+				status: undefined,
+				getSession: undefined,
+				authorize: undefined,
+				description: 'Test endpoint',
+			});
+			const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+
+			const event = createMockV1Event({
+				headers: { 'Content-Type': 'application/json' },
+				body: Buffer.from(JSON.stringify({ name: 'test' })).toString('base64'),
+				isBase64Encoded: true,
+			});
+
+			const result = adapter.getInput(event);
+			expect(result.body).toEqual({ name: 'test' });
+		});
+
+		it('should return raw string for non-JSON content-type', () => {
+			const endpoint = new Endpoint({
+				route: '/test',
+				method: 'POST',
+				fn: async () => ({ success: true }),
+				input: {},
+				output: z.object({ success: z.boolean() }),
+				services: [],
+				logger: mockLogger,
+				timeout: undefined,
+				memorySize: undefined,
+				status: undefined,
+				getSession: undefined,
+				authorize: undefined,
+				description: 'Test endpoint',
+			});
+			const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+
+			const event = createMockV1Event({
+				headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+				body: 'amount=100&currency=ZAR',
+			});
+
+			const result = adapter.getInput(event);
+			expect(result.body).toBe('amount=100&currency=ZAR');
+		});
+
+		it('should decode base64 and return string for form-urlencoded content', () => {
+			const endpoint = new Endpoint({
+				route: '/test',
+				method: 'POST',
+				fn: async () => ({ success: true }),
+				input: {},
+				output: z.object({ success: z.boolean() }),
+				services: [],
+				logger: mockLogger,
+				timeout: undefined,
+				memorySize: undefined,
+				status: undefined,
+				getSession: undefined,
+				authorize: undefined,
+				description: 'Test endpoint',
+			});
+			const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+
+			const event = createMockV1Event({
+				headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+				body: Buffer.from('amount=100&currency=ZAR').toString('base64'),
+				isBase64Encoded: true,
+			});
+
+			const result = adapter.getInput(event);
+			expect(result.body).toBe('amount=100&currency=ZAR');
+		});
+	});
+
 	describe('handler', () => {
 		it('should handle a simple GET request', async () => {
 			const endpoint = new Endpoint({
@@ -775,7 +887,7 @@ describe('AmazonApiGatewayV1Endpoint', () => {
 	});
 
 	describe('combined inputs', () => {
-		it('should handle array query parameters', async () => {
+		it('should handle array query parameters with bracket notation', async () => {
 			const querySchema = z.object({
 				tags: z.array(z.string()),
 				page: z.coerce.number().default(1),
@@ -808,9 +920,9 @@ describe('AmazonApiGatewayV1Endpoint', () => {
 			const handler = adapter.handler;
 
 			const event = createMockV1Event({
-				queryStringParameters: { tags: 'nodejs', page: '2' },
+				queryStringParameters: { 'tags[]': 'nodejs', page: '2' },
 				multiValueQueryStringParameters: {
-					tags: ['nodejs', 'typescript', 'javascript'],
+					'tags[]': ['nodejs', 'typescript', 'javascript'],
 					page: ['2'],
 				},
 			});
@@ -825,7 +937,7 @@ describe('AmazonApiGatewayV1Endpoint', () => {
 			});
 		});
 
-		it('should handle object query parameters with dot notation', async () => {
+		it('should handle object query parameters with bracket notation', async () => {
 			const querySchema = z.object({
 				filter: z.object({
 					name: z.string(),
@@ -867,9 +979,9 @@ describe('AmazonApiGatewayV1Endpoint', () => {
 
 			const event = createMockV1Event({
 				queryStringParameters: {
-					'filter.name': 'john',
-					'filter.status': 'active',
-					'filter.priority': '1',
+					'filter[name]': 'john',
+					'filter[status]': 'active',
+					'filter[priority]': '1',
 					sort: 'priority',
 				},
 			});

package/src/endpoints/__tests__/AmazonApiGatewayV2EndpointAdaptor.events.spec.ts

@@ -635,7 +635,7 @@ describe('AmazonApiGatewayV2Endpoint Events', () => {
 		expect(mockPublisher.publish).not.toHaveBeenCalled();
 	});
 
-	it('should handle comma-separated array query parameters', async () => {
+	it('should handle bracket notation array query parameters', async () => {
 		const mockPublisher: EventPublisher<TestEvent> = {
 			publish: vi.fn().mockResolvedValue(undefined),
 		};
@@ -702,8 +702,10 @@ describe('AmazonApiGatewayV2Endpoint Events', () => {
 				},
 			},
 			pathParameters: { id: '123' },
+			rawQueryString:
+				'tags%5B%5D=javascript&tags%5B%5D=typescript&tags%5B%5D=nodejs',
 			queryStringParameters: {
-				tags: 'javascript, typescript, nodejs', // V2 handles arrays as comma-separated
+				'tags[]': 'javascript,typescript,nodejs',
 			},
 		});
 		const context = createMockContext();

package/src/endpoints/__tests__/AmazonApiGatewayV2EndpointAdaptor.spec.ts

@@ -3,6 +3,7 @@ import { createMockContext, createMockV2Event } from '@geekmidas/testkit/aws';
 import type { Context } from 'aws-lambda';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { z } from 'zod';
+import { AmazonApiGatewayEndpoint } from '../AmazonApiGatewayEndpointAdaptor';
 import { AmazonApiGatewayV2Endpoint } from '../AmazonApiGatewayV2EndpointAdaptor';
 import { e } from '../EndpointFactory';
 
@@ -36,6 +37,78 @@ describe('AmazonApiGatewayV2Endpoint', () => {
 			});
 		});
 
+		it('should parse JSON body when content-type is application/json', () => {
+			const endpoint = e.get('/test').handle(() => ({ success: true }));
+			const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
+
+			const event = createMockV2Event({
+				headers: { 'content-type': 'application/json' },
+				body: JSON.stringify({ name: 'test' }),
+			});
+
+			const result = adapter.getInput(event);
+
+			expect(result.body).toEqual({ name: 'test' });
+		});
+
+		it('should decode base64-encoded JSON body', () => {
+			const endpoint = e.get('/test').handle(() => ({ success: true }));
+			const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
+
+			const event = createMockV2Event({
+				headers: { 'content-type': 'application/json' },
+				body: Buffer.from(JSON.stringify({ name: 'test' })).toString('base64'),
+				isBase64Encoded: true,
+			});
+
+			const result = adapter.getInput(event);
+
+			expect(result.body).toEqual({ name: 'test' });
+		});
+
+		it('should return base64-decoded string for non-JSON content-type', () => {
+			const endpoint = e.get('/test').handle(() => ({ success: true }));
+			const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
+
+			const event = createMockV2Event({
+				headers: { 'content-type': 'application/x-www-form-urlencoded' },
+				body: Buffer.from('amount=100&currency=ZAR').toString('base64'),
+				isBase64Encoded: true,
+			});
+
+			const result = adapter.getInput(event);
+
+			expect(result.body).toBe('amount=100&currency=ZAR');
+		});
+
+		it('should return raw string when content-type is not JSON', () => {
+			const endpoint = e.get('/test').handle(() => ({ success: true }));
+			const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
+
+			const event = createMockV2Event({
+				headers: { 'content-type': 'text/plain' },
+				body: 'plain-text-body',
+			});
+
+			const result = adapter.getInput(event);
+
+			expect(result.body).toBe('plain-text-body');
+		});
+
+		it('should default to JSON parsing when no content-type header', () => {
+			const endpoint = e.get('/test').handle(() => ({ success: true }));
+			const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
+
+			const event = createMockV2Event({
+				headers: {},
+				body: JSON.stringify({ name: 'test' }),
+			});
+
+			const result = adapter.getInput(event);
+
+			expect(result.body).toEqual({ name: 'test' });
+		});
+
 		it('should handle missing body, query, and params', () => {
 			const endpoint = e.get('/test').handle(() => ({ success: true }));
 			const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
@@ -139,7 +212,7 @@ describe('AmazonApiGatewayV2Endpoint', () => {
 			});
 		});
 
-		it('should handle array query parameters (comma-separated)', async () => {
+		it('should handle array query parameters with bracket notation', async () => {
 			const endpoint = e
 				.get('/search')
 				.query(
@@ -164,9 +237,10 @@ describe('AmazonApiGatewayV2Endpoint', () => {
 			const event = createMockV2Event({
 				routeKey: 'GET /search',
 				rawPath: '/search',
-				rawQueryString: 'tags=nodejs,typescript,javascript&limit=20',
+				rawQueryString:
+					'tags%5B%5D=nodejs&tags%5B%5D=typescript&tags%5B%5D=javascript&limit=20',
 				queryStringParameters: {
-					tags: 'nodejs,typescript,javascript',
+					'tags[]': 'nodejs,typescript,javascript',
 					limit: '20',
 				},
 			});
@@ -182,7 +256,7 @@ describe('AmazonApiGatewayV2Endpoint', () => {
 			});
 		});
 
-		it('should handle object query parameters with dot notation', async () => {
+		it('should handle object query parameters with bracket notation', async () => {
 			const endpoint = e
 				.get('/search')
 				.query(
@@ -210,10 +284,11 @@ describe('AmazonApiGatewayV2Endpoint', () => {
 			const event = createMockV2Event({
 				routeKey: 'GET /search',
 				rawPath: '/search',
-				rawQueryString: 'filter.category=electronics&filter.active=true',
+				rawQueryString:
+					'filter%5Bcategory%5D=electronics&filter%5Bactive%5D=true',
 				queryStringParameters: {
-					'filter.category': 'electronics',
-					'filter.active': 'true',
+					'filter[category]': 'electronics',
+					'filter[active]': 'true',
 				},
 			});
 
@@ -488,3 +563,67 @@ describe('AmazonApiGatewayV2Endpoint', () => {
 		});
 	});
 });
+
+describe('AmazonApiGatewayEndpoint.decodeBody', () => {
+	const decodeBody = AmazonApiGatewayEndpoint.decodeBody;
+
+	it('should return undefined for null/undefined body', () => {
+		expect(decodeBody(undefined, false, 'application/json')).toBeUndefined();
+		expect(decodeBody(null, false, 'application/json')).toBeUndefined();
+		expect(decodeBody('', false, 'application/json')).toBeUndefined();
+	});
+
+	it('should JSON.parse when content-type is application/json', () => {
+		const result = decodeBody('{"name":"test"}', false, 'application/json');
+		expect(result).toEqual({ name: 'test' });
+	});
+
+	it('should JSON.parse when content-type includes application/json with charset', () => {
+		const result = decodeBody(
+			'{"name":"test"}',
+			false,
+			'application/json; charset=utf-8',
+		);
+		expect(result).toEqual({ name: 'test' });
+	});
+
+	it('should decode base64 then JSON.parse for base64-encoded JSON', () => {
+		const encoded = Buffer.from('{"name":"test"}').toString('base64');
+		const result = decodeBody(encoded, true, 'application/json');
+		expect(result).toEqual({ name: 'test' });
+	});
+
+	it('should return raw string for non-JSON content-type', () => {
+		const result = decodeBody(
+			'amount=100&currency=ZAR',
+			false,
+			'application/x-www-form-urlencoded',
+		);
+		expect(result).toBe('amount=100&currency=ZAR');
+	});
+
+	it('should decode base64 and return string for non-JSON content-type', () => {
+		const encoded = Buffer.from('amount=100&currency=ZAR').toString('base64');
+		const result = decodeBody(
+			encoded,
+			true,
+			'application/x-www-form-urlencoded',
+		);
+		expect(result).toBe('amount=100&currency=ZAR');
+	});
+
+	it('should return raw string for text/plain', () => {
+		const result = decodeBody('hello world', false, 'text/plain');
+		expect(result).toBe('hello world');
+	});
+
+	it('should default to JSON parsing when content-type is undefined', () => {
+		const result = decodeBody('{"name":"test"}', false, undefined);
+		expect(result).toEqual({ name: 'test' });
+	});
+
+	it('should not JSON.parse a string that happens to be valid JSON when content-type is not JSON', () => {
+		const result = decodeBody('{"looks":"like json"}', false, 'text/plain');
+		expect(result).toBe('{"looks":"like json"}');
+	});
+});

package/src/endpoints/__tests__/EndpointBuilder.spec.ts

@@ -379,6 +379,41 @@ describe('EndpointBuilder', () => {
 			expect(endpoint.authorize).toBe(customAuth);
 		});
 
+		it('should set authorize via .authorize() method', () => {
+			const authFn = () => true;
+			const builder = new EndpointBuilder('/test', 'GET');
+			const result = builder.authorize(authFn);
+
+			expect(result).toBe(builder);
+			expect((builder as any)._authorize).toBe(authFn);
+		});
+
+		it('should pass .authorize() function to endpoint', () => {
+			const authFn = async () => false;
+			const endpoint = new EndpointBuilder('/test', 'POST')
+				.authorize(authFn)
+				.handle(async () => ({}));
+
+			expect(endpoint.authorize).toBe(authFn);
+		});
+
+		it('should chain .authorize() with body, query, and params', () => {
+			const endpoint = new EndpointBuilder('/users/:id', 'POST')
+				.body(z.object({ role: z.string() }))
+				.query(z.object({ verbose: z.string() }))
+				.params(z.object({ id: z.string() }))
+				.authorize(({ body, query, params }) => {
+					return (
+						body.role === 'admin' &&
+						params.id !== '' &&
+						query.verbose === 'true'
+					);
+				})
+				.handle(async () => ({}));
+
+			expect(endpoint.authorize).toBeDefined();
+		});
+
 		it('should allow setting custom session extractor', () => {
 			const customSession = async () => ({ userId: '123', role: 'admin' });
 			const builder = new EndpointBuilder('/test', 'GET');