@vercube/core 0.0.3 → 0.0.4

package/dist/Middleware/ValidationMiddleware.d.ts

@@ -1,23 +0,0 @@
-import { BaseMiddleware } from "../Services/Middleware/BaseMiddleware.js";
-import type { MiddlewareOptions } from "../Types/CommonTypes.js";
-/**
-* Middleware for validating request data against a schema
-* @class ValidationMiddleware
-* @implements {BaseMiddleware}
-* @description Validates incoming request data against a provided schema
-* @example
-* const middleware = new ValidationMiddleware();
-* await middleware.use(event, { schema: myValidationSchema });
-*/
-export declare class ValidationMiddleware implements BaseMiddleware {
-	private gValidationProvider;
-	/**
-	* Middleware function that processes the HTTP event
-	* @param {Request} request - The HTTP request object
-	* @param {Response} response - The HTTP response object
-	* @param {MiddlewareOptions} args - Additional arguments for the middleware
-	* @returns {Promise<void>} - A promise that resolves when the processing is complete
-	* @throws {BadRequestError} - If validation fails
-	*/
-	onRequest(request: Request, response: Response, args: MiddlewareOptions): Promise<void>;
-}

package/dist/Resolvers/Body.d.ts

@@ -1,22 +0,0 @@
-import { RouterTypes } from "../Types/RouterTypes.js";
-/**
-* Resolves and parses the request body from a RouterEvent.
-* 
-* @param {RouterTypes.RouterEvent} event - The router event containing the request to process
-* @returns {Promise<unknown>} A promise that resolves to:
-*   - The parsed JSON body if the request contains valid JSON
-*   - undefined if the request body is empty
-* @throws {BadRequestError} If the request body contains invalid JSON
-* 
-* @example
-* const body = await resolveRequestBody(event);
-* if (body) {
-*   // Process the parsed body
-* }
-* 
-* @remarks
-* - Currently only supports JSON content type
-* - Returns undefined for empty request bodies
-* - Throws BadRequestError for malformed JSON
-*/
-export declare function resolveRequestBody(event: RouterTypes.RouterEvent): Promise<unknown>;

package/dist/Resolvers/Headers.d.ts

@@ -1,14 +0,0 @@
-import { RouterTypes } from "../Types/RouterTypes.js";
-/**
-* Retrieves a specific header value from the request
-* @param {string} header - The name of the header to retrieve
-* @param {RouterTypes.RouterEvent} event - The router event containing the request
-* @returns {string | null} The header value if found, null otherwise
-*/
-export declare function getRequestHeader(header: string, event: RouterTypes.RouterEvent): string | null;
-/**
-* Retrieves all headers from the request
-* @param {RouterTypes.RouterEvent} event - The router event containing the request
-* @returns {Headers} The complete Headers object from the request
-*/
-export declare function getRequestHeaders(event: RouterTypes.RouterEvent): Headers;

package/dist/Resolvers/Query.d.ts

@@ -1,14 +0,0 @@
-import { RouterTypes } from "../Types/RouterTypes.js";
-/**
-* Resolves a single query parameter from the URL of a router event
-* @param name - The name of the query parameter to resolve
-* @param event - The router event containing the request URL
-* @returns The value of the query parameter if found, null otherwise
-*/
-export declare function resolveQueryParam(name: string, event: RouterTypes.RouterEvent): string | null;
-/**
-* Resolves all query parameters from the URL of a router event
-* @param event - The router event containing the request URL
-* @returns An object containing all query parameters as key-value pairs
-*/
-export declare function resolveQueryParams(event: RouterTypes.RouterEvent): Record<string, string>;

package/dist/Resolvers/RouterParam.d.ts

@@ -1,13 +0,0 @@
-import { RouterTypes } from "../Types/RouterTypes.js";
-/**
-* Resolves a router parameter from the event object
-* @param param - The parameter name to resolve from the router event
-* @param event - The router event object containing parameters
-* @returns The resolved parameter value if it exists, null otherwise
-* @example
-* ```typescript
-* const value = resolveRouterParam('id', routerEvent);
-* // Returns the 'id' parameter value from routerEvent.params or null
-* ```
-*/
-export declare function resolveRouterParam(param: string, event: RouterTypes.RouterEvent): string | null;

package/dist/Services/Config/RuntimeConfig.d.ts

@@ -1,22 +0,0 @@
-import { ConfigTypes } from "../../Types/ConfigTypes.js";
-/**
-* RuntimeConfig class manages the runtime configuration for the Vercube application.
-* This class provides a centralized way to access and modify runtime configuration settings.
-*/
-export declare class RuntimeConfig {
-	/**
-	* Private field to store the runtime configuration object.
-	* @private
-	*/
-	private fRuntimeConfig;
-	/**
-	* Gets the current runtime configuration.
-	* @returns {ConfigTypes.RuntimeConfig} The current runtime configuration object.
-	*/
-	get runtimeConfig(): ConfigTypes.RuntimeConfig;
-	/**
-	* Sets the runtime configuration.
-	* @param {ConfigTypes.RuntimeConfig} value - The new runtime configuration object to set.
-	*/
-	set runtimeConfig(value: ConfigTypes.RuntimeConfig);
-}

package/dist/Services/ErrorHandler/DefaultErrorHandlerProvider.d.ts

@@ -1,16 +0,0 @@
-import { ErrorHandlerProvider } from "./ErrorHandlerProvider.js";
-/**
-* Default error handler provider
-*
-* @class DefaultErrorHandlerProvider
-*/
-export declare class DefaultErrorHandlerProvider extends ErrorHandlerProvider {
-	private gLogger;
-	/**
-	* Handles an error that occurred during request processing
-	*
-	* @param error - The Error object containing error details
-	* @returns Promise<Response> | Response - The response to be sent to the client
-	*/
-	handleError(error: Error): Response;
-}

package/dist/Services/ErrorHandler/ErrorHandlerProvider.d.ts

@@ -1,16 +0,0 @@
-/**
-* Abstract class representing an error handler provider
-* Provides a common interface for different error handler implementations
-*
-* @abstract
-* @class ErrorHandlerProvider
-*/
-export declare abstract class ErrorHandlerProvider {
-	/**
-	* Handles an error that occurred during request processing
-	* 
-	* @param error - The Error object containing error details
-	* @returns Promise<Response> | Response - The response to be sent to the client
-	*/
-	abstract handleError(error: Error): Promise<Response> | Response;
-}

package/dist/Services/Hooks/HooksService.d.ts

@@ -1,76 +0,0 @@
-/**
-* This module is responsible for managing type-safe hooks observer pattern.
-*
-* You may create an Hook class that will function as single hook with some data,
-* eg:
-*
-* class ECylinderSelected {
-*   public cylinder: ICylinder;
-* }
-*
-* And then you can trigger this hook at any time, passing proper payload:
-*
-* HooksService.trigger(ECylinderSelected, { cylinder: someCylinder });
-*
-* And you can also listen to this hook:
-*
-* HooksService.listen(ECylinderSelected, payload => console.log(payload.cylinder));
-*
-*
-* HooksService.on(ECylinderSelected, payload => console.log(payload.cylinder));
-*
-* Everything 100% typechecked.
-*/
-import type { HooksTypes } from "../../Types/HooksTypes.js";
-/**
-* This class is responsible for managing events.
-*/
-export declare class HooksService {
-	private fLastId;
-	private fHandlers;
-	/**
-	* Registers listener for event of particular type. Everytime event is called, the listener
-	* will be executed.
-	*
-	* @param type type of event, simple class
-	* @param callback callback fired when event is triggered
-	* @returns unique ID for event listener, can be used to disable this listener
-	*/
-	on<T>(type: HooksTypes.HookType<T>, callback: HooksTypes.HookCallback<T>): HooksTypes.HookID;
-	/**
-	* Waits for single event execution and removes the listener immediately after.
-	*
-	* @example
-	* this.gCart.addItem(product);
-	* await this.gEvents.waitFor(CartUpdatedEvent);
-	* console.log('here cart updated event is already called');
-	*
-	* @param type type of event to wait for
-	* @param timeout timeout param in ms - if event is not thrown until this time, it'll reject. passing null disables the timeout
-	* @returns promise with event data that resolves when event is finally called
-	*/
-	waitFor<T>(type: HooksTypes.HookType<T>, timeout?: number | null): Promise<T>;
-	/**
-	* Removes listener from particular event.
-	* @param eventId eventId returned from .on() method.
-	* @throws Error if event was not registered
-	*/
-	off<T>(eventId: HooksTypes.HookID): void;
-	/**
-	* Triggers event, calling all listener callbacks. Will return Promise of number,
-	* that is resolved when all asynchronous listeners are called.
-	* @param type type of trigger, simple class
-	* @param data data which will be passed to listeners, based on event class
-	* @return number of listeners that were notified
-	*/
-	trigger<T>(type: HooksTypes.HookType<T>, data?: HooksTypes.HookData<T>): Promise<number>;
-	/**
-	* Converts plain object to it's class equivalent.
-	* It's NOT class-transformer, it performs basic key assigment.
-	*
-	* @param ClassConstructor event constructor
-	* @param data event data to be mapped to constructor
-	* @return class type of event
-	*/
-	private objectToClass;
-}

package/dist/Services/HttpServer/HttpServer.d.ts

@@ -1,57 +0,0 @@
-import { ConfigTypes } from "@vercube/core";
-/**
-* HTTP server implementation for handling incoming web requests
-* 
-* This class is responsible for:
-* - Initializing and managing the HTTP server
-* - Routing incoming requests to appropriate handlers
-* - Processing HTTP responses
-*/
-export declare class HttpServer {
-	/**
-	* DI container for resolving dependencies
-	*/
-	private gContainer;
-	/**
-	* Router service for resolving routes
-	*/
-	private gRouter;
-	/**
-	* Handler for processing HTTP requests
-	*/
-	private gRequestHandler;
-	/**
-	* Static server for serving static files
-	*/
-	private gStaticRequestHandler;
-	/**
-	* Underlying server instance
-	* @private
-	*/
-	private fServer;
-	/**
-	* Initializes the HTTP server and starts listening for requests
-	* 
-	* @returns {Promise<void>} A promise that resolves when the server is ready
-	*/
-	initialize(config: ConfigTypes.Config): Promise<void>;
-	/**
-	* Listens for incoming requests on the HTTP server
-	* 
-	* @returns {Promise<void>} A promise that resolves when the server is ready to listen
-	*/
-	listen(): Promise<void>;
-	/**
-	* Processes an incoming HTTP request
-	* 
-	* This method:
-	* 1. Resolves the route for the request
-	* 2. Returns a 404 response if no route is found
-	* 3. Delegates to the request handler for matched routes
-	* 
-	* @param {Request} request - The incoming HTTP request
-	* @returns {Promise<Response>} The HTTP response
-	* @private
-	*/
-	handleRequest(request: Request): Promise<Response>;
-}

package/dist/Services/Metadata/MetadataResolver.d.ts

@@ -1,42 +0,0 @@
-import type { MetadataTypes } from "../../Types/MetadataTypes.js";
-import { RouterTypes } from "../../Types/RouterTypes.js";
-/**
-* Class responsible for resolving metadata for route handlers.
-*/
-export declare class MetadataResolver {
-	/**
-	* Resolves the URL for a given instance and path.
-	*
-	* @param {MetadataTypes.ResolveUrlParams} params - The parameters for resolving the URL.
-	* @return {string} The resolved URL.
-	*/
-	resolveUrl(params: MetadataTypes.ResolveUrlParams): string;
-	resolveMethod(ctx: MetadataTypes.Metadata, propertyName: string): MetadataTypes.Method;
-	/**
-	* Resolves arguments for a given event.
-	*
-	* @param {MetadataTypes.Arg[]} args - The arguments to resolve.
-	* @param {RouterTypes.RouterEvent} event - The event to resolve arguments for.
-	* @return {unknown[]} The resolved arguments.
-	* @public
-	*/
-	resolveArgs(args: MetadataTypes.Arg[], event: RouterTypes.RouterEvent): Promise<MetadataTypes.Arg[]>;
-	/**
-	* Resolves an argument for a given event.
-	*
-	* @param {MetadataTypes.Arg} arg - The argument to resolve.
-	* 
-	* @return {unknown} The resolved argument.
-	* @private
-	*/
-	private resolveArg;
-	/**
-	* Resolves middleware functions for a given context and property name.
-	*
-	* @param {MetadataTypes.Ctx} ctx - The metadata context object
-	* @param {string} propertyName - The name of the property to resolve middlewares for
-	* @returns {MetadataTypes.Middleware[]} Array of middleware functions that apply globally or to the specific property
-	* @public
-	*/
-	resolveMiddlewares(ctx: MetadataTypes.Metadata, propertyName: string): MetadataTypes.Middleware[];
-}

package/dist/Services/Middleware/BaseMiddleware.d.ts

@@ -1,31 +0,0 @@
-import type { MaybePromise, MiddlewareOptions } from "../../Types/CommonTypes.js";
-/**
-* BaseMiddleware class that serves as a base for all middleware implementations.
-*/
-export declare class BaseMiddleware<
-	T = any,
-	U = any
-> {
-	/**
-	* Middleware function that processes the HTTP event.
-	* This method should be overridden by subclasses to implement specific middleware logic.
-	* WARNING: This method cannot return a value, it will be ignored.
-	* Middleware can only modify the event object or throw an HttpError like BadRequestError, ForbiddenError, etc.
-	*
-	* @param {Request} request - The HTTP Request to process
-	* @param {T[]} args - Additional arguments for the middleware.
-	* @returns {void | Promise<void>} - A void or a promise that resolves when the processing is complete.
-	*/
-	onRequest?(request: Request, response: Response, args: MiddlewareOptions<T>): MaybePromise<void | Response>;
-	/**
-	* Middleware function that processes the response.
-	* This method should be overridden by subclasses to implement specific middleware logic.
-	* WARNING: This method cannot return a value, it will be ignored.
-	* Middleware can only modify the event object or throw an HttpError like BadRequestError, ForbiddenError, etc.
-	*
-	* @param {Request} request - The HTTP Request to process
-	* @param {Response} response - The HTTP Response to process
-	* @returns {void | Promise<void>} - A void or a promise that resolves when the processing is complete.
-	*/
-	onResponse?(request: Request, response: Response, payload: U): MaybePromise<void | Response>;
-}

package/dist/Services/Middleware/GlobalMiddlewareRegistry.d.ts

@@ -1,31 +0,0 @@
-import { MetadataTypes } from "../../Types/MetadataTypes.js";
-import { BaseMiddleware } from "./BaseMiddleware.js";
-interface GlobalMiddlewareParams<T> extends Omit<MetadataTypes.Middleware<T>, "middleware"> {}
-/**
-* Manages global middleware registration and retrieval
-* 
-* This class provides functionality to register and retrieve global middleware
-* configurations. It allows for adding middleware with specific options and
-* retrieving them in a standardized format.
-*/
-export declare class GlobalMiddlewareRegistry {
-	private fMiddlewares;
-	/**
-	* Retrieves all registered global middleware configurations
-	* 
-	* @returns {MetadataTypes.Middleware[]} An array of middleware configurations
-	*/
-	get middlewares(): MetadataTypes.Middleware[];
-	/**
-	* Registers a global middleware configuration
-	* 
-	* @param {typeof BaseMiddleware<T, U>} middleware - The middleware class to register
-	* @param {GlobalMiddlewareParams<T>} opts - The middleware options
-	* @returns {void}
-	*/
-	registerGlobalMiddleware<
-		T = unknown,
-		U = unknown
-	>(middleware: typeof BaseMiddleware<T, U>, opts?: GlobalMiddlewareParams<T>): void;
-}
-export {};

package/dist/Services/Plugins/BasePlugin.d.ts

@@ -1,16 +0,0 @@
-import type { App } from "../../Common/App.js";
-/**
-* Represents a Plugin.
-*/
-export declare class BasePlugin<T = unknown> {
-	/**
-	* The name of the plugin.
-	*/
-	name: string;
-	/**
-	* Uses the plugin with the given app.
-	* @param {App} app - The application instance.
-	* @returns {void | Promise<void>} - A void or a promise that resolves to void.
-	*/
-	use(app: App, options?: T): void | Promise<void>;
-}

package/dist/Services/Plugins/PluginsRegistry.d.ts

@@ -1,26 +0,0 @@
-import type { App } from "../../Common/App.js";
-import { BasePlugin } from "./BasePlugin.js";
-export declare class PluginsRegistry {
-	private gContainer;
-	/** Holds the list of plugins */
-	private fPlugins;
-	/**
-	* Registers a plugin.
-	*
-	* @param {Plugin} plugin - The plugin to register.
-	* @param {unknown} options - The options to pass to the plugin.
-	*/
-	register<T = unknown>(plugin: typeof BasePlugin<T>, options?: T): void;
-	/**
-	* Gets the list of registered plugins.
-	*
-	* @returns {Plugin[]} The list of registered plugins.
-	*/
-	get plugins(): BasePlugin[];
-	/**
-	* Resolves the plugins.
-	*
-	* @param {App} app - The application instance.
-	*/
-	init(app: App): Promise<void>;
-}

package/dist/Services/Router/RequestHandler.d.ts

@@ -1,63 +0,0 @@
-import { RouterTypes } from "../../Types/RouterTypes.js";
-/**
-* Options for configuring a request handler
-* @interface RequestHandlerOptions
-*/
-export interface RequestHandlerOptions {
-	/** The controller instance that contains the handler method */
-	instance: any;
-	/** The name of the method to be used as the handler */
-	propertyName: string;
-}
-/**
-* Handles HTTP requests by preparing and executing route handlers with their associated middlewares
-* 
-* The RequestHandler is responsible for:
-* - Preparing route handlers with their metadata
-* - Executing middleware chains (before and after)
-* - Processing request/response lifecycle
-* - Error handling during request processing
-*/
-export declare class RequestHandler {
-	/** Resolver for extracting metadata from controller classes and methods */
-	private gMetadataResolver;
-	/** DI container for resolving dependencies */
-	private gContainer;
-	private gGlobalMiddlewareRegistry;
-	/**
-	* Prepares a route handler by resolving its metadata and middlewares
-	* 
-	* @param {RequestHandlerOptions} params - Configuration options for the handler
-	* @returns {RouterTypes.RouterHandler} A prepared handler with resolved metadata and middlewares
-	*/
-	prepareHandler(params: RequestHandlerOptions): RouterTypes.RouterHandler;
-	/**
-	* Processes an HTTP request through the middleware chain and route handler
-	* 
-	* The request handling lifecycle:
-	* 1. Execute "before" middlewares
-	* 2. Apply route actions (status codes, redirects, etc.)
-	* 3. Resolve handler arguments
-	* 4. Execute the route handler
-	* 5. Execute "after" middlewares
-	* 6. Format and return the final response
-	* 
-	* @param {Request} request - The incoming HTTP request
-	* @param {RouterTypes.RouteMatched<RouterTypes.RouterHandler>} route - The matched route with handler data
-	* @returns {Promise<Response>} The HTTP response
-	*/
-	handleRequest(request: Request, route: RouterTypes.RouteMatched<RouterTypes.RouterHandler>): Promise<Response>;
-	/**
-	* Processes and merges response overrides from middlewares or actions
-	* 
-	* This method handles different response formats:
-	* - If a full Response object is provided, it's used directly
-	* - If ResponseInit is provided, it's merged with the base response
-	* 
-	* @param {Response | ResponseInit} response - The response or response options to apply
-	* @param {Response} [base] - The base response to extend (optional)
-	* @returns {Response} The processed response with applied overrides
-	* @private
-	*/
-	private processOverrideResponse;
-}

package/dist/Services/Router/Router.d.ts

@@ -1,40 +0,0 @@
-import { RouterTypes } from "../../Types/RouterTypes.js";
-/**
-* Router service responsible for managing application routes
-* 
-* This class provides functionality to initialize the router,
-* register routes, and resolve incoming requests to their
-* appropriate handlers.
-*/
-export declare class Router {
-	/**
-	* Service for triggering application hooks
-	*/
-	private gHooksService;
-	/**
-	* Internal router context that stores all registered routes
-	* @private
-	*/
-	private fRouterContext;
-	/**
-	* Registers a new route in the router
-	* 
-	* @param {RouterTypes.Route} route - The route configuration to add
-	* @throws {Error} If router is not initialized
-	*/
-	addRoute(route: RouterTypes.Route): void;
-	/**
-	* Initializes the router and triggers related hooks
-	* 
-	* This method creates a new router context and triggers
-	* the before and after initialization hooks.
-	*/
-	initialize(): void;
-	/**
-	* Resolves a route based on the HTTP method and path
-	* 
-	* @param {RouterTypes.RouteFind} route - The route to resolve
-	* @returns {RouterTypes.RouteMatched<RouterTypes.RouterHandler> | undefined} The matched route or undefined if no match found
-	*/
-	resolve(route: RouterTypes.RouteFind): RouterTypes.RouteMatched<RouterTypes.RouterHandler> | undefined;
-}

package/dist/Services/Router/StaticRequestHandler.d.ts

@@ -1,38 +0,0 @@
-import { ConfigTypes } from "../../Types/ConfigTypes.js";
-/**
-* Handles serving static files over HTTP
-* 
-* The StaticRequestHandler is responsible for:
-* - Serving static files from configured directories
-* - Setting appropriate content types and headers
-* - Handling caching and ETags
-* - Processing GET requests for static assets
-*/
-export declare class StaticRequestHandler {
-	/**
-	* The options for the static server
-	*/
-	private fOptions;
-	/**
-	* Initializes the static server with the given options
-	* 
-	* @param {ConfigTypes.ServerOptions['static']} options - The options for the static server
-	* @returns {void}
-	*/
-	initialize(options: ConfigTypes.ServerOptions["static"]): void;
-	/**
-	* Handles HTTP requests for static files
-	* 
-	* @param {Request} request - The incoming HTTP request
-	* @returns {Promise<void | Response>} A promise that resolves to void or a Response object
-	*/
-	handleRequest(request: Request): Promise<void | Response>;
-	/**
-	* Serves a static file and returns a Response object
-	* 
-	* @param {string} path - The path to the file to serve
-	* @param {any} stats - The stats object for the file
-	* @returns {Promise<Response>} A promise that resolves to a Response object
-	*/
-	private serveFile;
-}

package/dist/Services/Validation/StandardSchemaValidationProvider.d.ts

@@ -1,17 +0,0 @@
-import { ValidationProvider } from "./ValidationProvider.js";
-import { ValidationTypes } from "../../Types/ValidationTypes.js";
-/**
-* StandardSchemaValidationProvider implements validation using StandardSchema schema validation
-* @see https://github.com/standard-schema/standard-schema
-* @class
-* @implements {ValidationProvider}
-*/
-export declare class StandardSchemaValidationProvider implements ValidationProvider {
-	/**
-	* Validates data against a schema
-	* @param {ValidationTypes.Schema} schema - The schema to validate against
-	* @param {ValidationTypes.Input} data - The data to validate
-	* @return {ValidationTypes.Result | Promise<ValidationTypes.Result>} The validation result
-	*/
-	validate(schema: ValidationTypes.Schema, data: ValidationTypes.Input): ValidationTypes.Result | Promise<ValidationTypes.Result>;
-}

package/dist/Services/Validation/ValidationProvider.d.ts

@@ -1,17 +0,0 @@
-import { ValidationTypes } from "../../Types/ValidationTypes.js";
-/**
-* Abstract class representing a validation provider
-* Provides a common interface for different validation implementations
-* 
-* @abstract
-* @class ValidationProvider
-*/
-export declare abstract class ValidationProvider {
-	/**
-	* Validates data against a given schema
-	* @param schema - The validation schema to check against
-	* @param data - The data to validate
-	* @returns A validation result object or Promise of validation result
-	*/
-	abstract validate(schema: ValidationTypes.Schema, data: ValidationTypes.Input): ValidationTypes.Result | Promise<ValidationTypes.Result>;
-}

package/dist/Types/CommonTypes.d.ts

@@ -1,7 +0,0 @@
-import { MetadataTypes } from "./MetadataTypes.js";
-export { FastResponse } from "srvx";
-export type MaybePromise<T> = T | Promise<T>;
-export interface MiddlewareOptions<T = any> {
-	middlewareArgs?: T;
-	methodArgs?: MetadataTypes.Arg[];
-}