tspace-spear 1.0.0-rc

package/build/lib/core/server/index.d.ts

@@ -0,0 +1,202 @@
+/// <reference types="node" />
+import { Server, ServerResponse } from 'http';
+import { Router, TContext, TNextFunction, TApplication } from '../..';
+/**
+ *
+ * The 'Spear' class is used to create a server and handle HTTP requests.
+ *
+ * @returns {Spear} application
+ * @example
+ * new Application()
+ *  .get('/' , () => 'Hello world!')
+ *  .get('/json' , () => {
+ *     return {
+ *       message : 'Hello world!'
+ *     }
+ *   })
+ *  .listen(3000 , () => console.log('server listening on port : 3000'))
+ *
+ */
+declare class Spear {
+    private readonly _controllers?;
+    private readonly _middlewares?;
+    private readonly _globalPrefix;
+    private readonly _router;
+    private _errorHandler;
+    private _globalMiddlewares;
+    private _formatResponse;
+    private _onListeners;
+    private _fileUploadOptions;
+    constructor({ controllers, middlewares, globalPrefix, logger }?: TApplication);
+    /**
+     * The 'enableCors' is used to enable the cors origins on the server.
+     *
+     * @params {Object}
+     * @property {(string | RegExp)[]} origins
+     * @property {boolean} credentials
+     * @returns
+     */
+    enableCors({ origins, credentials }?: {
+        origins?: (string | RegExp)[];
+        credentials?: boolean;
+    }): this;
+    /**
+     * The 'use' method is used to add the middleware into the request pipeline.
+     *
+     * @callback {Function} middleware
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    use(middleware: (ctx: TContext, next: TNextFunction) => void): this;
+    /**
+     * The 'useRouter' method is used to add the router in the request context.
+     *
+     * @parms {Function} router
+     * @property  {Function} router - get() , post() , put() , patch() , delete()
+     * @returns {this}
+     */
+    useRouter(router: Router): this;
+    /**
+     * The 'useBodyParser' method is a middleware used to parse the request body of incoming HTTP requests.
+     *
+     * @returns {this}
+     */
+    useBodyParser(): this;
+    /**
+     * The 'useCookiesParser' method is a middleware used to parses cookies attached to the client request object.
+     *
+     * @returns {this}
+     */
+    useCookiesParser(): this;
+    /**
+     * The 'useFileUpload' method is a middleware used to handler file uploads. It adds a file upload of incoming HTTP requests.
+     *
+     * @param {?Object}
+     * @property {?number} limits
+     * @property {?boolean} useTempFiles
+     * @property {?string} tempFileDir
+     * @property {?Object} removeTempFile
+     * @property {boolean} removeTempFile.remove
+     * @property {number} removeTempFile.ms
+     * @returns
+     */
+    useFileUpload({ limits, useTempFiles, tempFileDir, removeTempFile }?: {
+        limits?: number;
+        useTempFiles?: boolean;
+        tempFileDir?: string;
+        removeTempFile?: {
+            remove: boolean;
+            ms: number;
+        };
+    }): this;
+    /**
+     * The 'formatResponse' method is used to format the response
+     *
+     * @param {function} format
+     * @returns
+     */
+    formatResponse(format: (r: unknown, statusCode: number) => any): this;
+    /**
+     * The 'errorHandler' method is middleware that is specifically designed to handle errors that occur during the processing of requests
+     *
+     * @param {function} error
+     * @returns
+     */
+    errorHandler(error: (err: Error, ctx: TContext) => any): this;
+    /**
+     * The 'notFoundHandler' method is middleware that is specifically designed to handle errors notfound that occur during the processing of requests
+     *
+     * @param {function} notfound
+     * @returns
+     */
+    notFoundHandler(notfound: (ctx: TContext) => any): this;
+    /**
+     * The 'get' method is used to add the request handler to the router for the 'GET' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    get(path: string, ...handlers: ((ctx: TContext, next: TNextFunction) => any)[]): this;
+    /**
+     * The 'post' method is used to add the request handler to the router for the 'POST' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    post(path: string, ...handlers: ((ctx: TContext, next: TNextFunction) => any)[]): this;
+    /**
+     * The 'put' method is used to add the request handler to the router for the 'PUT' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    put(path: string, ...handlers: ((ctx: TContext, next: TNextFunction) => any)[]): this;
+    /**
+     * The 'patch' method is used to add the request handler to the router for the 'PATCH' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    patch(path: string, ...handlers: ((ctx: TContext, next: TNextFunction) => any)[]): this;
+    /**
+     * The 'delete' method is used to add the request handler to the router for the 'DELETE' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    delete(path: string, ...handlers: ((ctx: TContext, next: TNextFunction) => any)[]): this;
+    /**
+     * The 'all' method is used to add the request handler to the router for the 'all' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {function} next  - go to next function
+     * @returns {this}
+     */
+    all(path: string, ...handlers: ((ctx: TContext, next: TNextFunction) => any)[]): this;
+    /**
+     * The 'listen' method is used to bind and start a server to a particular port and optionally a hostname.
+     *
+     * @param {number} port
+     * @param {function} cb
+     * @returns
+     */
+    listen(port: number | (() => ServerResponse) | undefined, cb: (callback: {
+        server: Server;
+        port: number;
+    }) => void): Promise<void>;
+    private _logger;
+    private _import;
+    private _registerControllers;
+    private _registerMiddlewares;
+    private _filesParser;
+    private _bodyParser;
+    private _cookiesParser;
+    private _customizeResponse;
+    private _nextFunction;
+    private _wrapHandlers;
+    private _wrapResponse;
+    private _createServer;
+    private _normalizePath;
+}
+export { Spear };
+export declare class Application extends Spear {
+}
+export default Spear;