@vercube/core 0.0.1-alpha.15

package/dist/Resolvers/Query.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,16 @@
+/**
+* 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

@@ -0,0 +1,76 @@
+/**
+* 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

@@ -0,0 +1,51 @@
+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 {
+	/**
+	* Router service for resolving routes
+	*/
+	private gRouter;
+	/**
+	* Handler for processing HTTP requests
+	*/
+	private gRequestHandler;
+	/**
+	* Error handler provider for managing error responses
+	*/
+	private gErrorHandlerProvider;
+	/**
+	* 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>;
+	/**
+	* 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
+	*/
+	private handleRequest;
+}

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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,65 @@
+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;
+	/** Provider for handling errors during request processing */
+	private gErrorHandlerProvider;
+	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

@@ -0,0 +1,40 @@
+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.
+	*/
+	init(): 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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,17 @@
+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

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

package/dist/Types/ConfigTypes.d.ts

@@ -0,0 +1,120 @@
+import type { LoggerTypes } from "@vercube/logger";
+/**
+* Namespace containing configuration type definitions for the Vercube framework.
+*/
+export declare namespace ConfigTypes {
+	interface RuntimeConfig {
+		/**
+		* Session configuration options.
+		*/
+		session?: {
+			/**
+			* The secret used to sign the session ID cookie.
+			*/
+			secret?: string
+			/**
+			* The name of the session ID cookie.
+			*/
+			name?: string
+			/**
+			* The duration of time for the session to be active.
+			*/
+			duration?: number
+		};
+	}
+	interface ExperimentalOptions {}
+	interface BuildOptions {
+		/**
+		* The root directory for the application.
+		*/
+		root?: string;
+		/**
+		* The entry point file for the application build.
+		*/
+		entry?: string;
+		/**
+		* Output configuration for build artifacts.
+		*/
+		output?: {
+			/**
+			* The main output directory for build artifacts.
+			*/
+			dir?: string
+			/**
+			* The directory for public/client-side build artifacts.
+			*/
+			publicDir?: string
+		};
+		/**
+		* The bundler to use for the application build.
+		*/
+		bundler?: "rolldown";
+	}
+	interface ServerOptions {
+		/**
+		* The runtime environment for the application.
+		*/
+		runtime?: "node" | "bun" | "deno";
+		/**
+		* The hostname to bind the server to.
+		*/
+		host?: string;
+		/**
+		* The port number to listen on.
+		*/
+		port?: number;
+		/**
+		* HTTPS configuration options.
+		*/
+		https?: false | {
+			/**
+			* Path to the SSL key file.
+			*/
+			key: string
+			/**
+			* Path to the SSL certificate file.
+			*/
+			cert: string
+		};
+		/**
+		* Static server options
+		*/
+		static: {
+			dirs: string[]
+			maxAge?: number
+			immutable?: boolean
+			etag?: boolean
+		};
+	}
+	interface Config {
+		/**
+		* Flag indicating if the application is running in production mode.
+		*/
+		production?: boolean;
+		/**
+		* Flag indicating if the application is running in development mode.
+		*/
+		dev?: boolean;
+		/**
+		* The logging level for the application.
+		*/
+		logLevel?: LoggerTypes.Level;
+		/**
+		* Server configuration options.
+		*/
+		server?: ServerOptions;
+		/**
+		* Runtime configuration for the application.
+		*/
+		runtime?: RuntimeConfig;
+		/**
+		* Experimental features configuration.
+		*/
+		experimental?: ExperimentalOptions;
+		/**
+		* Build configuration options.
+		* This property is only used when using vercube cli.
+		*/
+		build?: BuildOptions;
+	}
+}