@noony-serverless/core 0.1.5 → 0.2.0

package/build/core/containerPool.js

@@ -1,103 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.containerPool = exports.ContainerPool = void 0;
-const typedi_1 = __importDefault(require("typedi"));
-/**
- * Performance optimization: Container Pool for reusing TypeDI containers
- * This reduces object creation overhead and improves memory efficiency
- */
-class ContainerPool {
-    availableContainers = [];
-    maxPoolSize = 10;
-    createdContainers = 0;
-    constructor(maxPoolSize = 10) {
-        this.maxPoolSize = maxPoolSize;
-    }
-    /**
-     * Get a container from the pool or create a new one
-     */
-    acquire() {
-        if (this.availableContainers.length > 0) {
-            return this.availableContainers.pop();
-        }
-        // Create new container if pool is empty and under limit
-        if (this.createdContainers < this.maxPoolSize) {
-            this.createdContainers++;
-            return typedi_1.default.of();
-        }
-        // If pool is at capacity, create a temporary container
-        // This should rarely happen in normal usage
-        return typedi_1.default.of();
-    }
-    /**
-     * Return a container to the pool for reuse
-     */
-    release(container) {
-        if (this.availableContainers.length < this.maxPoolSize) {
-            // Reset container state by removing all instances
-            // This prevents memory leaks and cross-request contamination
-            this.resetContainer(container);
-            this.availableContainers.push(container);
-        }
-        // If pool is full, let the container be garbage collected
-    }
-    /**
-     * Reset container state to prevent cross-request contamination
-     * Note: TypeDI containers are isolated by default, so we mainly need
-     * to clear any manually set values
-     */
-    resetContainer(_container) {
-        try {
-            // For TypeDI containers created with Container.of(), each container
-            // is already isolated. We just need to ensure no memory leaks.
-            // The container will be garbage collected when released from pool
-            // if it contains too much data
-            // TypeDI containers are self-contained and don't need explicit reset
-            // This is a placeholder for future enhancements if needed
-        }
-        catch (error) {
-            // If any issues occur, don't add back to pool
-            console.warn('Failed to reset container, discarding:', error);
-        }
-    }
-    /**
-     * Get pool statistics for monitoring
-     */
-    getStats() {
-        return {
-            available: this.availableContainers.length,
-            created: this.createdContainers,
-            maxSize: this.maxPoolSize,
-        };
-    }
-    /**
-     * Warm up the pool by pre-creating containers
-     */
-    warmUp(count = 5) {
-        const warmUpCount = Math.min(count, this.maxPoolSize);
-        for (let i = 0; i < warmUpCount; i++) {
-            if (this.createdContainers < this.maxPoolSize) {
-                const container = typedi_1.default.of();
-                this.createdContainers++;
-                this.availableContainers.push(container);
-            }
-        }
-    }
-    /**
-     * Clear all containers from the pool
-     */
-    clear() {
-        this.availableContainers = [];
-        this.createdContainers = 0;
-    }
-}
-exports.ContainerPool = ContainerPool;
-// Global container pool instance
-const containerPool = new ContainerPool(15); // Slightly higher limit for serverless
-exports.containerPool = containerPool;
-// Warm up the pool for better cold start performance
-containerPool.warmUp(3);
-//# sourceMappingURL=containerPool.js.map

package/build/middlewares/validationMiddleware.d.ts

@@ -1,154 +0,0 @@
-import { BaseMiddleware, Context } from '../core';
-import { z } from 'zod';
-/**
- * Middleware class that validates request data (body or query parameters) using Zod schemas.
- * Automatically detects GET requests and validates query parameters, or validates body for other methods.
- *
- * @implements {BaseMiddleware}
- *
- * @example
- * User registration validation:
- * ```typescript
- * import { z } from 'zod';
- * import { Handler, ValidationMiddleware } from '@noony-serverless/core';
- *
- * const userRegistrationSchema = z.object({
- *   email: z.string().email(),
- *   password: z.string().min(8),
- *   firstName: z.string().min(1),
- *   lastName: z.string().min(1),
- *   age: z.number().int().min(18).max(120)
- * });
- *
- * const registerHandler = new Handler()
- *   .use(bodyParser())
- *   .use(new ValidationMiddleware(userRegistrationSchema))
- *   .handle(async (context) => {
- *     const validatedUser = context.req.validatedBody;
- *     const newUser = await createUser(validatedUser);
- *     return { success: true, userId: newUser.id };
- *   });
- * ```
- *
- * @example
- * GET request query parameter validation:
- * ```typescript
- * const searchSchema = z.object({
- *   q: z.string().min(1),
- *   page: z.string().regex(/^\d+$/).transform(Number).default('1'),
- *   limit: z.string().regex(/^\d+$/).transform(Number).default('10'),
- *   category: z.string().optional()
- * });
- *
- * const searchHandler = new Handler()
- *   .use(new ValidationMiddleware(searchSchema))
- *   .handle(async (context) => {
- *     const { q, page, limit, category } = context.req.query;
- *     const results = await searchItems(q, { page, limit, category });
- *     return { success: true, results, query: { q, page, limit, category } };
- *   });
- * ```
- *
- * @example
- * Product creation with nested validation:
- * ```typescript
- * const productSchema = z.object({
- *   name: z.string().min(1).max(100),
- *   description: z.string().max(1000),
- *   price: z.number().positive(),
- *   category: z.enum(['electronics', 'clothing', 'books', 'home']),
- *   specifications: z.record(z.string()),
- *   images: z.array(z.string().url()).max(5),
- *   inventory: z.object({
- *     inStock: z.boolean(),
- *     quantity: z.number().int().min(0),
- *     warehouse: z.string()
- *   })
- * });
- *
- * const createProductHandler = new Handler()
- *   .use(bodyParser())
- *   .use(new ValidationMiddleware(productSchema))
- *   .handle(async (context) => {
- *     const productData = context.req.validatedBody;
- *     const product = await createProduct(productData);
- *     return { success: true, productId: product.id };
- *   });
- * ```
- */
-export declare class ValidationMiddleware implements BaseMiddleware {
-    private readonly schema;
-    constructor(schema: z.ZodSchema);
-    before(context: Context): Promise<void>;
-}
-/**
- * Factory function that creates a validation middleware using Zod schema.
- * Automatically validates request body for non-GET requests or query parameters for GET requests.
- *
- * @param schema - Zod schema to validate against
- * @returns BaseMiddleware object with validation logic
- *
- * @example
- * Login endpoint validation:
- * ```typescript
- * import { z } from 'zod';
- * import { Handler, validationMiddleware } from '@noony-serverless/core';
- *
- * const loginSchema = z.object({
- *   email: z.string().email(),
- *   password: z.string().min(1),
- *   rememberMe: z.boolean().optional()
- * });
- *
- * const loginHandler = new Handler()
- *   .use(bodyParser())
- *   .use(validationMiddleware(loginSchema))
- *   .handle(async (context) => {
- *     const { email, password, rememberMe } = context.req.validatedBody;
- *     const token = await authenticate(email, password);
- *     return { success: true, token, rememberMe };
- *   });
- * ```
- *
- * @example
- * API filtering with query validation:
- * ```typescript
- * const filterSchema = z.object({
- *   status: z.enum(['active', 'inactive', 'pending']).optional(),
- *   sort: z.enum(['name', 'date', 'status']).default('name'),
- *   order: z.enum(['asc', 'desc']).default('asc'),
- *   limit: z.coerce.number().int().min(1).max(100).default(10)
- * });
- *
- * const getItemsHandler = new Handler()
- *   .use(validationMiddleware(filterSchema))
- *   .handle(async (context) => {
- *     const filters = context.req.query;
- *     const items = await getFilteredItems(filters);
- *     return { success: true, items, appliedFilters: filters };
- *   });
- * ```
- *
- * @example
- * File upload validation:
- * ```typescript
- * const uploadSchema = z.object({
- *   filename: z.string().min(1),
- *   mimeType: z.string().regex(/^(image|document)\//),
- *   size: z.number().max(10 * 1024 * 1024), // 10MB max
- *   description: z.string().max(200).optional(),
- *   tags: z.array(z.string()).max(10).optional()
- * });
- *
- * const uploadHandler = new Handler()
- *   .use(bodyParser())
- *   .use(validationMiddleware(uploadSchema))
- *   .handle(async (context) => {
- *     const fileData = context.req.validatedBody;
- *     const upload = await processFileUpload(fileData);
- *     return { success: true, fileId: upload.id };
- *   });
- * ```
- */
-export declare const validationMiddleware: (schema: z.ZodSchema) => BaseMiddleware;
-//# sourceMappingURL=validationMiddleware.d.ts.map

package/build/middlewares/validationMiddleware.js

@@ -1,185 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validationMiddleware = exports.ValidationMiddleware = void 0;
-const core_1 = require("../core");
-const zod_1 = require("zod");
-const validate = async (schema, context) => {
-    try {
-        const data = context.req.method === 'GET' ? context.req.query : context.req.parsedBody;
-        const validated = await schema.parseAsync(data);
-        if (context.req.method === 'GET') {
-            context.req.query = validated;
-        }
-        else {
-            context.req.validatedBody = validated;
-        }
-    }
-    catch (error) {
-        if (error instanceof zod_1.z.ZodError) {
-            throw new core_1.ValidationError('Validation error', JSON.stringify(error.errors));
-        }
-        throw error;
-    }
-};
-/**
- * Middleware class that validates request data (body or query parameters) using Zod schemas.
- * Automatically detects GET requests and validates query parameters, or validates body for other methods.
- *
- * @implements {BaseMiddleware}
- *
- * @example
- * User registration validation:
- * ```typescript
- * import { z } from 'zod';
- * import { Handler, ValidationMiddleware } from '@noony-serverless/core';
- *
- * const userRegistrationSchema = z.object({
- *   email: z.string().email(),
- *   password: z.string().min(8),
- *   firstName: z.string().min(1),
- *   lastName: z.string().min(1),
- *   age: z.number().int().min(18).max(120)
- * });
- *
- * const registerHandler = new Handler()
- *   .use(bodyParser())
- *   .use(new ValidationMiddleware(userRegistrationSchema))
- *   .handle(async (context) => {
- *     const validatedUser = context.req.validatedBody;
- *     const newUser = await createUser(validatedUser);
- *     return { success: true, userId: newUser.id };
- *   });
- * ```
- *
- * @example
- * GET request query parameter validation:
- * ```typescript
- * const searchSchema = z.object({
- *   q: z.string().min(1),
- *   page: z.string().regex(/^\d+$/).transform(Number).default('1'),
- *   limit: z.string().regex(/^\d+$/).transform(Number).default('10'),
- *   category: z.string().optional()
- * });
- *
- * const searchHandler = new Handler()
- *   .use(new ValidationMiddleware(searchSchema))
- *   .handle(async (context) => {
- *     const { q, page, limit, category } = context.req.query;
- *     const results = await searchItems(q, { page, limit, category });
- *     return { success: true, results, query: { q, page, limit, category } };
- *   });
- * ```
- *
- * @example
- * Product creation with nested validation:
- * ```typescript
- * const productSchema = z.object({
- *   name: z.string().min(1).max(100),
- *   description: z.string().max(1000),
- *   price: z.number().positive(),
- *   category: z.enum(['electronics', 'clothing', 'books', 'home']),
- *   specifications: z.record(z.string()),
- *   images: z.array(z.string().url()).max(5),
- *   inventory: z.object({
- *     inStock: z.boolean(),
- *     quantity: z.number().int().min(0),
- *     warehouse: z.string()
- *   })
- * });
- *
- * const createProductHandler = new Handler()
- *   .use(bodyParser())
- *   .use(new ValidationMiddleware(productSchema))
- *   .handle(async (context) => {
- *     const productData = context.req.validatedBody;
- *     const product = await createProduct(productData);
- *     return { success: true, productId: product.id };
- *   });
- * ```
- */
-class ValidationMiddleware {
-    schema;
-    constructor(schema) {
-        this.schema = schema;
-    }
-    async before(context) {
-        await validate(this.schema, context);
-    }
-}
-exports.ValidationMiddleware = ValidationMiddleware;
-/**
- * Factory function that creates a validation middleware using Zod schema.
- * Automatically validates request body for non-GET requests or query parameters for GET requests.
- *
- * @param schema - Zod schema to validate against
- * @returns BaseMiddleware object with validation logic
- *
- * @example
- * Login endpoint validation:
- * ```typescript
- * import { z } from 'zod';
- * import { Handler, validationMiddleware } from '@noony-serverless/core';
- *
- * const loginSchema = z.object({
- *   email: z.string().email(),
- *   password: z.string().min(1),
- *   rememberMe: z.boolean().optional()
- * });
- *
- * const loginHandler = new Handler()
- *   .use(bodyParser())
- *   .use(validationMiddleware(loginSchema))
- *   .handle(async (context) => {
- *     const { email, password, rememberMe } = context.req.validatedBody;
- *     const token = await authenticate(email, password);
- *     return { success: true, token, rememberMe };
- *   });
- * ```
- *
- * @example
- * API filtering with query validation:
- * ```typescript
- * const filterSchema = z.object({
- *   status: z.enum(['active', 'inactive', 'pending']).optional(),
- *   sort: z.enum(['name', 'date', 'status']).default('name'),
- *   order: z.enum(['asc', 'desc']).default('asc'),
- *   limit: z.coerce.number().int().min(1).max(100).default(10)
- * });
- *
- * const getItemsHandler = new Handler()
- *   .use(validationMiddleware(filterSchema))
- *   .handle(async (context) => {
- *     const filters = context.req.query;
- *     const items = await getFilteredItems(filters);
- *     return { success: true, items, appliedFilters: filters };
- *   });
- * ```
- *
- * @example
- * File upload validation:
- * ```typescript
- * const uploadSchema = z.object({
- *   filename: z.string().min(1),
- *   mimeType: z.string().regex(/^(image|document)\//),
- *   size: z.number().max(10 * 1024 * 1024), // 10MB max
- *   description: z.string().max(200).optional(),
- *   tags: z.array(z.string()).max(10).optional()
- * });
- *
- * const uploadHandler = new Handler()
- *   .use(bodyParser())
- *   .use(validationMiddleware(uploadSchema))
- *   .handle(async (context) => {
- *     const fileData = context.req.validatedBody;
- *     const upload = await processFileUpload(fileData);
- *     return { success: true, fileId: upload.id };
- *   });
- * ```
- */
-const validationMiddleware = (schema) => ({
-    before: async (context) => {
-        await validate(schema, context);
-    },
-});
-exports.validationMiddleware = validationMiddleware;
-//# sourceMappingURL=validationMiddleware.js.map