@geekmidas/constructs 3.0.3 → 3.0.6

package/src/endpoints/EndpointBuilder.ts

@@ -63,7 +63,8 @@ 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, TDatabase> =
+		() => true;
 	_rateLimit?: RateLimitConfig;
 	_availableAuthorizers: Authorizer[] = [];
 	_authorizerName?: TAuthorizers[number];
@@ -263,6 +264,13 @@ export class EndpointBuilder<
 		return this;
 	}
 
+	authorize(
+		fn: AuthorizeFn<TServices, TLogger, TSession, TInput, TDatabase>,
+	): this {
+		this._authorize = fn;
+		return this;
+	}
+
 	rateLimit(config: RateLimitConfig): this {
 		this._rateLimit = config;
 		return this;

package/src/endpoints/EndpointFactory.ts

@@ -51,7 +51,13 @@ export class EndpointFactory<
 > {
 	private defaultServices: TServices = [] as unknown as TServices;
 	private basePath: TBasePath = '' as TBasePath;
-	private defaultAuthorizeFn?: AuthorizeFn<TServices, TLogger, TSession>;
+	private defaultAuthorizeFn?: AuthorizeFn<
+		TServices,
+		TLogger,
+		TSession,
+		undefined,
+		TDatabase
+	>;
 	private defaultEventPublisher:
 		| Service<TEventPublisherServiceName, TEventPublisher>
 		| undefined;
@@ -419,7 +425,7 @@ export class EndpointFactory<
 
 	// Create a new factory with authorization
 	authorize(
-		fn: AuthorizeFn<TServices, TLogger, TSession>,
+		fn: AuthorizeFn<TServices, TLogger, TSession, undefined, TDatabase>,
 	): EndpointFactory<
 		TServices,
 		TBasePath,
@@ -749,7 +755,9 @@ export class EndpointFactory<
 		>({
 			defaultServices: this.defaultServices,
 			basePath: this.basePath,
-			defaultAuthorizeFn: this.defaultAuthorizeFn,
+			defaultAuthorizeFn: this.defaultAuthorizeFn as unknown as
+				| AuthorizeFn<TServices, TLogger, TSession, undefined, T>
+				| undefined,
 			defaultLogger: this.defaultLogger,
 			// Reset session extractor when database changes - user should call .session() after .database()
 			// to get proper type inference for the new database type
@@ -988,7 +996,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
@@ -1117,7 +1125,13 @@ export interface EndpointFactoryOptions<
 > {
 	defaultServices?: TServices;
 	basePath?: TBasePath;
-	defaultAuthorizeFn?: AuthorizeFn<TServices, TLogger, TSession>;
+	defaultAuthorizeFn?: AuthorizeFn<
+		TServices,
+		TLogger,
+		TSession,
+		undefined,
+		TDatabase
+	>;
 	defaultLogger?: TLogger;
 	defaultSessionExtractor?: SessionFn<TServices, TLogger, TSession, TDatabase>;
 	defaultEventPublisher?: Service<TEventPublisherServiceName, TEventPublisher>;

package/src/endpoints/HonoEndpointAdaptor.ts

@@ -393,7 +393,17 @@ export class HonoEndpoint<
 							services,
 							logger,
 							session,
-						});
+							...(rawDb !== undefined && { db: rawDb }),
+							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,
+						} as any);
 
 						if (!isAuthorized) {
 							logger.warn('Unauthorized access attempt');

package/src/endpoints/TestEndpointAdaptor.ts

@@ -216,7 +216,11 @@ export class TestEndpointAdaptor<
 				services: ctx.services,
 				logger,
 				session,
-			});
+				...(rawDb !== undefined && { db: rawDb }),
+				body,
+				query,
+				params,
+			} as any);
 
 			if (!isAuthorized) {
 				logger.warn('Unauthorized access attempt');

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({

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);
@@ -490,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');

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

@@ -996,6 +996,111 @@ describe('HonoEndpointAdaptor', () => {
 			const response = await app.request('/protected');
 			expect(response.status).toBe(500);
 		});
+
+		it('should pass body to authorize function', async () => {
+			const authorizeSpy = vi.fn(() => true);
+			const bodySchema = z.object({ role: z.string() });
+
+			const endpoint = new Endpoint({
+				route: '/protected',
+				method: 'POST',
+				fn: async () => ({ success: true }),
+				input: { body: bodySchema },
+				output: z.object({ success: z.boolean() }),
+				services: [],
+				logger: mockLogger,
+				timeout: undefined,
+				memorySize: undefined,
+				status: undefined,
+				getSession: undefined,
+				authorize: authorizeSpy,
+				description: undefined,
+			});
+
+			const adaptor = new HonoEndpoint(endpoint);
+			const app = new Hono();
+
+			adaptor.addRoute(serviceDiscovery, app);
+
+			const response = await app.request('/protected', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ role: 'admin' }),
+			});
+
+			expect(response.status).toBe(200);
+			expect(authorizeSpy).toHaveBeenCalledTimes(1);
+			expect(authorizeSpy.mock.calls[0][0]).toMatchObject({
+				body: { role: 'admin' },
+			});
+		});
+
+		it('should pass params to authorize function', async () => {
+			const authorizeSpy = vi.fn(() => true);
+			const paramsSchema = z.object({ id: z.string() });
+
+			const endpoint = new Endpoint({
+				route: '/resources/:id',
+				method: 'GET',
+				fn: async () => ({ success: true }),
+				input: { params: paramsSchema },
+				output: z.object({ success: z.boolean() }),
+				services: [],
+				logger: mockLogger,
+				timeout: undefined,
+				memorySize: undefined,
+				status: undefined,
+				getSession: undefined,
+				authorize: authorizeSpy,
+				description: undefined,
+			});
+
+			const adaptor = new HonoEndpoint(endpoint);
+			const app = new Hono();
+
+			adaptor.addRoute(serviceDiscovery, app);
+
+			const response = await app.request('/resources/res-42');
+
+			expect(response.status).toBe(200);
+			expect(authorizeSpy).toHaveBeenCalledTimes(1);
+			expect(authorizeSpy.mock.calls[0][0]).toMatchObject({
+				params: { id: 'res-42' },
+			});
+		});
+
+		it('should deny request when authorize uses body to reject', async () => {
+			const bodySchema = z.object({ role: z.string() });
+
+			const endpoint = new Endpoint({
+				route: '/admin',
+				method: 'POST',
+				fn: async () => ({ success: true }),
+				input: { body: bodySchema },
+				output: z.object({ success: z.boolean() }),
+				services: [],
+				logger: mockLogger,
+				timeout: undefined,
+				memorySize: undefined,
+				status: undefined,
+				getSession: undefined,
+				authorize: ({ body }: any) => body?.role === 'admin',
+				description: undefined,
+			});
+
+			const adaptor = new HonoEndpoint(endpoint);
+			const app = new Hono();
+
+			adaptor.addRoute(serviceDiscovery, app);
+
+			const response = await app.request('/admin', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ role: 'viewer' }),
+			});
+
+			expect(response.status).toBe(401);
+		});
 	});
 
 	describe('output validation', () => {