jimpex 7.0.1 → 8.0.0

package/types/app/index.d.ts

@@ -1,417 +0,0 @@
-/// <reference types="node" />
-import Jimple from 'jimple';
-export type Express = express.Express;
-export type SpdyServer = https.Server;
-export type Provider = {
-  register: import('wootils/esm/shared/jimpleFns').ProviderRegisterFn;
-};
-export type Controller = {
-  /**
-   * The function Jimpex calls when mounting the
-   * controller.
-   */
-  connect: import('../types').ControllerConnectFn;
-  /**
-   * A flag set to `true` to identify the
-   * resource as a routes controller.
-   */
-  controller: boolean;
-};
-export type ControllerProvider = {
-  /**
-   * The function Jimpex calls when
-   * registering the provider and the one
-   * that has to generate the controller.
-   */
-  register: import('../types').ControllerProviderRegisterFn;
-};
-export type MiddlewareLike =
-  | import('../types').Middleware
-  | express.RequestHandler<
-      import('express-serve-static-core').ParamsDictionary,
-      any,
-      any,
-      qs.ParsedQs,
-      Record<string, any>
-    >
-  | express.ErrorRequestHandler<
-      import('express-serve-static-core').ParamsDictionary,
-      any,
-      any,
-      qs.ParsedQs,
-      Record<string, any>
-    >;
-export type Server = import('http').Server | https.Server;
-export type JimpexStartCallback = (
-  appConfiguration: import('wootils/esm/node/appConfiguration').AppConfiguration,
-) => any;
-export type JimpexOptions = {
-  /**
-   * The app version. To be used on the configuration. Default `'0.0.0'`.
-   */
-  version: string;
-  /**
-   * The size limit for the requests payload. Default `'15MB'`.
-   */
-  filesizeLimit: string;
-  /**
-   * Whether or not to automatically call the `boot` method after initialization.
-   * Default `true`.
-   */
-  boot: boolean;
-  /**
-   * Whether or not to enable the proxy mode, so all providers, controllers and middlewares
-   * will receive a proxied reference of the container, in which they can set and get
-   * resources using dot notation.
-   */
-  proxy: boolean;
-  /**
-   * The options for the app configuration service.
-   */
-  configuration: import('../types').JimpexConfigurationOptions;
-  /**
-   * The options for the app static `middleware`.
-   */
-  statics: import('../types').JimpexStaticsOptions;
-  /**
-   * The options for the Express app.
-   */
-  express: import('../types').JimpexExpressOptions;
-  /**
-   * To tell the app which services should be registered when instantiated.
-   */
-  defaultServices: import('../types').JimpexDefaultServicesOptions;
-};
-/**
- * Jimpex is a mix of Jimple, a Javascript port of Pimple dependency injection container,
- * and Express, one of the most popular web frameworks for Node.
- *
- * @augments Jimple
- * @parent module:core
- * @todo Implement `helmet`.
- */
-export class Jimpex extends Jimple {
-  /**
-   * @param {Partial<JimpexOptions>} [options={}]
-   * Preferences to customize the application.
-   * @param {?Object} [configuration=null]
-   * The default configuration for the `appConfiguration` service.
-   */
-  constructor(options?: Partial<JimpexOptions>, configuration?: any | null);
-  /**
-   * The application options.
-   *
-   * @type {JimpexOptions}
-   * @access protected
-   * @ignore
-   */
-  _options: JimpexOptions;
-  /**
-   * If the `proxy` option was set to `true`, this property will have a reference for a
-   * proxy of the container, in which resources can be registered and obtained using dot
-   * notation.
-   *
-   * @type {?Proxy<Jimpex>}
-   * @access protected
-   * @ignore
-   */
-  _proxy: ProxyConstructor | null;
-  /**
-   * The Express application Jimpex uses under the hood.
-   *
-   * @type {Express}
-   * @access protected
-   * @ignore
-   */
-  _express: Express;
-  /**
-   * When Jimpex is used with HTTP2 enabled, this property will be used to store the
-   * "patched"
-   * version of Express that uses Spdy.
-   *
-   * @type {?SpdyServer}
-   * @access protected
-   * @ignore
-   */
-  _spdy: SpdyServer | null;
-  /**
-   * When the application starts, this will be the instance of the server.
-   *
-   * @type {?Server}
-   * @access protected
-   * @ignore
-   */
-  _instance: Server | null;
-  /**
-   * A list of functions that return controllers and middlewares. When the application
-   * starts,
-   * the queue will be processed and those controllers and middlewares will be added to
-   * the server instance The reason they are not added directly like with a regular
-   * Express implementation is that services on Jimple use lazy loading, and adding
-   * middlewares and controllers as they come could cause errors if they depend on
-   * services that are not yet registered.
-   *
-   * @type {Function[]}
-   * @access protected
-   * @ignore
-   */
-  _mountQueue: Function[];
-  /**
-   * A list with all the top routes controlled by the application. Every time a
-   * controller is mounted, its route will be added here.
-   *
-   * @type {string[]}
-   * @access protected
-   * @ignore
-   */
-  _controlledRoutes: string[];
-  /**
-   * This is where the app would register all its specific services, middlewares and controllers.
-   */
-  boot(): void;
-  /**
-   * Disables the server TLS validation.
-   */
-  disableTLSValidation(): void;
-  /**
-   * This is an alias of `start`. The idea is for it to be used on serverless platforms,
-   * where you don't get to start your app, you just have export it.
-   *
-   * @param {?number}              [port=null]  In case the configuration doesn't
-   *                                            already have it,
-   *                                            this is the port where the application
-   *                                            will use to run. If this parameter is
-   *                                            used, the method will overwrite the
-   *                                            `port`
-   *                                            setting on the configuration service.
-   * @param {?JimpexStartCallback} [fn=null]    A callback function to be called when
-   *                                            the server starts.
-   * @returns {Server} The server instance.
-   */
-  listen(port?: number | null, fn?: JimpexStartCallback | null): Server;
-  /**
-   * Mounts a controller on a specific route.
-   *
-   * @param {string} route
-   * The route for the controller.
-   * @param {Controller | ControllerProvider} controller
-   * The route controller.
-   */
-  mount(route: string, controller: Controller | ControllerProvider): void;
-  /**
-   * Gets "safe" reference for the container that validates if the "proxy mode" is
-   * enabled, in order to provide the proxy or the actual instance.
-   *
-   * @returns {Jimpex}
-   */
-  ref(): Jimpex;
-  /**
-   * Registers a provider to extend the application.
-   *
-   * @param {Provider} provider  The provider to register.
-   */
-  register(provider: Provider): void;
-  /**
-   * Starts the app server.
-   *
-   * @param {?JimpexStartCallback} [fn=null]  A callback function to be called when the
-   *                                          server starts.
-   * @returns {Object} The server instance.
-   */
-  start(fn?: JimpexStartCallback | null): any;
-  _server: import('../types').Server;
-  /**
-   * Stops the server instance.
-   */
-  stop(): void;
-  /**
-   * Tries to access a resource on the container, but if is not present, it won't throw
-   * an error,
-   * it will just return `null`.
-   *
-   * @param {string} name  The name of the resource.
-   * @returns {*}
-   * @throws {Error} If there's an error other than the one generated when the
-   *                 resource doesn't exist.
-   */
-  try(name: string): any;
-  /**
-   * Adds a middleware.
-   *
-   * @param {MiddlewareLike} middleware  The middleware to use.
-   */
-  use(middleware: MiddlewareLike): void;
-  /**
-   * The Express app Jimpex uses under the hood.
-   *
-   * @type {Express}
-   */
-  get express(): express.Express;
-  /**
-   * The server instance that gets created when the app is started.
-   *
-   * @returns {?Server}
-   */
-  get instance(): import('../types').Server;
-  /**
-   * The app options.
-   *
-   * @type {JimpexOptions}
-   */
-  get options(): import('../types').JimpexOptions;
-  /**
-   * A list of all the top routes controlled by the app.
-   *
-   * @type {string[]}
-   */
-  get routes(): string[];
-  /**
-   * Helper method to add static folders to the app.
-   *
-   * @param {string}  route           The route for the static folder.
-   * @param {string}  [folder='']     The path to the folder. If not defined, it will
-   *                                  use the value from `route`.
-   * @param {boolean} [onHome=false]  If `true`, the path to the folder will be relative
-   *                                  to where the app is being executed
-   *                                  (`process.cwd()`), otherwise, it will be relative
-   *                                  to where the executable file is located.
-   * @access protected
-   * @ignore
-   */
-  _addStaticsFolder(route: string, folder?: string, onHome?: boolean): void;
-  /**
-   * Emits an app event with a reference to this class instance.
-   *
-   * @param {string} name  The name of the event on {@link JimpexEvents}.
-   * @param {...*}   args  Extra parameters for the listeners.
-   * @access protected
-   * @ignore
-   */
-  _emitEvent(name: string, ...args: any[]): void;
-  /**
-   * Validates the configuration and chooses the server the application needs to use: If
-   * HTTP2 is enabled, it will use Spdy; if HTTP is enabled but HTTP is not, it will use
-   * the native HTTPS server; otherwise, it will be just the Express instance.
-   *
-   * @returns {Server}
-   * @throws {Error} If HTTP2 is enabled but HTTPS is not.
-   * @throws {Error} If HTTPS is enabled but there's no `https.credentials` object.
-   * @throws {Error} If HTTPS is enabled and no creadentials are found.
-   * @access protected
-   * @ignore
-   */
-  _getServer(): Server;
-  /**
-   * This method is like a "lifecycle method", it gets executed on the constructor right
-   * before the "boot step". The idea is for the method to be a helper when application
-   * is defined by subclassing {@link Jimpex}: the application could register all
-   * important services here and the routes on boot, then, if the implementation needs
-   * to access or overwrite a something, it can send `boot: false`, access/register what
-   * it needs and then call `boot()`. That would be impossible for an application
-   * without overwriting the constructor and the boot functionality.
-   *
-   * @access protected
-   */
-  _init(): void;
-  /**
-   * It generates overwrites for the class options when they are created. This method is
-   * a helper for when the application is defined by subclassing {@link Jimpex}: It's
-   * highly probable that if the application needs to change the default options, it
-   * would want to do it right from the class, instead of having to do it on every
-   * implementation. A way to do it would be overwriting the constructor and calling
-   * `super` with the custom overwrites; this method exists so that won't be necessary:
-   * when creating the `options`, the constructor will merge the result of this method
-   * on top of the default ones.
-   *
-   * @returns {Partial<JimpexOptions>}
-   * @access protected
-   */
-  _initOptions(): Partial<JimpexOptions>;
-  /**
-   * Loads the contents of a dictionary of files that need to be used for HTTPS
-   * credentials.
-   *
-   * @param {boolean} onHome
-   * If this is `true`, the path of the files will be relative to the project root
-   * directory;
-   * otherwise, it will be relative to the directory where the application executable is
-   * located.
-   * @param {Object.<string, string>} credentialsInfo
-   * The dictionary where the keys are the type of credentials (`ca`,
-   * `cert` and/or `key`) and the values the paths to the files.
-   * @returns {Object.<string, string>}
-   * @access protected
-   * @ignore
-   */
-  _loadCredentials(
-    onHome: boolean,
-    credentialsInfo: {
-      [x: string]: string;
-    },
-  ): {
-    [x: string]: string;
-  };
-  /**
-   * Processes and mount all the resources on the `mountQueue`.
-   *
-   * @access protected
-   * @ignore
-   */
-  _mountResources(): void;
-  /**
-   * Sends a target object to a list of reducer events so they can modify or replace it.
-   * This method also sends a reference to this class instance as the last parameter of
-   * the event.
-   *
-   * @param {string} name    The name of the event on {@link JimpexEvents}.
-   * @param {*}      target  The targe object to reduce.
-   * @param {...*}   args    Extra parameters for the listeners.
-   * @returns {*} An object of the same type as the `target`.
-   * @access protected
-   * @ignore
-   */
-  _reduceWithEvent(name: string, target: any, ...args: any[]): any;
-  /**
-   * Creates the configuration service.
-   *
-   * @access protected
-   * @ignore
-   */
-  _setupConfiguration(): void;
-  /**
-   * Registers the _'core services'_.
-   *
-   * @access protected
-   * @ignore
-   */
-  _setupCoreServices(): void;
-  /**
-   * Based on the constructor received options, register or not the default services.
-   *
-   * @access protected
-   * @ignore
-   */
-  _setupDefaultServices(): void;
-  /**
-   * Creates and configure the Express instance.
-   *
-   * @access protected
-   * @ignore
-   */
-  _setupExpress(): void;
-}
-/**
- * Creates a new instance of {@link Jimpex}.
- *
- * @param {Partial<JimpexOptions>} [options={}]
- * Preferences to customize the application.
- * @param {?Object} [configuration=null]
- * The default configuration for the `appConfiguration` service.
- * @returns {Jimpex}
- */
-export function jimpex(
-  options?: Partial<JimpexOptions>,
-  configuration?: any | null,
-): Jimpex;
-import express = require('express');
-import https = require('https');

package/types/constants/eventNames.d.ts

@@ -1,93 +0,0 @@
-export = eventNames;
-/**
- * The name of all the events {@link Jimpex} can trigger.
- *
- * @typedef {Object} JimpexEvents
- * @property {string} beforeStop               Called before closing the instance of the
- *                                             app.
- * @property {string} start                    Called from the `listen` callback, when the
- *                                             app is ready to be used.
- * @property {string} afterStart               Called from the `listen` callback, when all
- *                                             controllers and middlewares have been
- *                                             mounted.
- * @property {string} afterStartCallback       Called right after the callback sent to
- *                                             `start`
- *                                             gets executed.
- * @property {string} beforeStart              Called before `listen` is executed on the
- *                                             Express app.
- * @property {string} afterStop                Called after the app instance has been
- *                                             closed and deleted.
- * @property {string} routeAdded               Called every time a new route is added to
- *                                             the app.
- * @property {string} controllerWillBeMounted  This is for a reducer event. It gets called
- *                                             before mounting a router or a set of routes
- *                                             to the app in order to "reduce it".
- * @property {string} middlewareWillBeUsed     This is for a reducer event. It gets called
- *                                             before using a middleware in order to
- *                                             "reduce it".
- * @parent module:constants
- */
-/**
- * The name of all the events {@link Jimpex} can trigger.
- *
- * @type {JimpexEvents}
- * @parent module:constants
- */
-declare const eventNames: JimpexEvents;
-declare namespace eventNames {
-    export { JimpexEvents };
-}
-/**
- * The name of all the events {@link Jimpex } can trigger.
- */
-type JimpexEvents = {
-    /**
-     * Called before closing the instance of the
-     * app.
-     */
-    beforeStop: string;
-    /**
-     * Called from the `listen` callback, when the
-     * app is ready to be used.
-     */
-    start: string;
-    /**
-     * Called from the `listen` callback, when all
-     * controllers and middlewares have been
-     * mounted.
-     */
-    afterStart: string;
-    /**
-     * Called right after the callback sent to
-     * `start`
-     * gets executed.
-     */
-    afterStartCallback: string;
-    /**
-     * Called before `listen` is executed on the
-     * Express app.
-     */
-    beforeStart: string;
-    /**
-     * Called after the app instance has been
-     * closed and deleted.
-     */
-    afterStop: string;
-    /**
-     * Called every time a new route is added to
-     * the app.
-     */
-    routeAdded: string;
-    /**
-     * This is for a reducer event. It gets called
-     * before mounting a router or a set of routes
-     * to the app in order to "reduce it".
-     */
-    controllerWillBeMounted: string;
-    /**
-     * This is for a reducer event. It gets called
-     * before using a middleware in order to
-     * "reduce it".
-     */
-    middlewareWillBeUsed: string;
-};

package/types/constants/index.d.ts

@@ -1,2 +0,0 @@
-export { eventNames };
-import eventNames = require("./eventNames");

package/types/controllers/common/configuration.d.ts

@@ -1,71 +0,0 @@
-export type ExpressMiddleware = import('../../types').ExpressMiddleware;
-export type ExpressResponse = import('../../types').ExpressResponse;
-export type AppConfiguration = import('../../types').AppConfiguration;
-export type ResponsesBuilder = import('../../services/http/responsesBuilder').ResponsesBuilder;
-export type Controller = import('../../types').Controller;
-/**
- * @typedef {import('../../types').ExpressMiddleware} ExpressMiddleware
- * @typedef {import('../../types').ExpressResponse} ExpressResponse
- * @typedef {import('../../types').AppConfiguration} AppConfiguration
- * @typedef {import('../../services/http/responsesBuilder').ResponsesBuilder} ResponsesBuilder
- * @typedef {import('../../types').Controller} Controller
- * @prettierignore
- */
-/**
- * Provides the handlers and middlwares to show and switch configurations.
- *
- * @parent module:controllers
- */
-export class ConfigurationController {
-    /**
-     * @param {AppConfiguration} appConfiguration  To read the app configuration.
-     * @param {ResponsesBuilder} responsesBuilder  To generate the JSON responses.
-     */
-    constructor(appConfiguration: AppConfiguration, responsesBuilder: ResponsesBuilder);
-    /**
-     * A local reference for the `appConfiguration` service.
-     *
-     * @type {AppConfiguration}
-     * @access protected
-     * @ignore
-     */
-    _appConfiguration: AppConfiguration;
-    /**
-     * A local reference for the `responsesBuilder` service.
-     *
-     * @type {ResponsesBuilder}
-     * @access protected
-     * @ignore
-     */
-    _responsesBuilder: ResponsesBuilder;
-    /**
-     * Send a response with the current app configuration as a body.
-     *
-     * @param {ExpressResponse} res  The server response.
-     */
-    getConfigurationResponse(res: ExpressResponse): void;
-    /**
-     * Returns the middleware to show the current configuration.
-     *
-     * @returns {ExpressMiddleware}
-     */
-    showConfiguration(): ExpressMiddleware;
-    /**
-     * Returns the middleware to switch the current configuration.
-     *
-     * @returns {ExpressMiddleware}
-     */
-    switchConfiguration(): ExpressMiddleware;
-}
-/**
- * This controller is kind of special as it will only mount the routes if the
- * `debug.configurationController` setting of the app configuration is `true`.
- * It provides routes for:
- * - Showing the current configuration.
- * - Switching the configuration, but only if the service allows it.
- *
- * @type {Controller}
- * @parent module:controllers
- * @todo Don't use an array to return the routes.
- */
-export const configurationController: Controller;

package/types/controllers/common/health.d.ts

@@ -1,55 +0,0 @@
-export type ExpressMiddleware = import('../../types').ExpressMiddleware;
-export type AppConfiguration = import('../../types').AppConfiguration;
-export type Controller = import('../../types').Controller;
-export type ResponsesBuilder = import('../../services/http/responsesBuilder').ResponsesBuilder;
-/**
- * @typedef {import('../../types').ExpressMiddleware} ExpressMiddleware
- * @typedef {import('../../types').AppConfiguration} AppConfiguration
- * @typedef {import('../../types').Controller} Controller
- * @typedef {import('../../services/http/responsesBuilder').ResponsesBuilder} ResponsesBuilder
- * @prettierignore
- */
-/**
- * Provides the handler to show a some minimal health information about the app:
- * - app version.
- * - configuration name.
- *
- * @parent module:controllers
- */
-export class HealthController {
-    /**
-     * @param {AppConfiguration} appConfiguration  To read the app version and the
-     *                                             configuration name.
-     * @param {ResponsesBuilder} responsesBuilder  To generate the JSON response.
-     */
-    constructor(appConfiguration: AppConfiguration, responsesBuilder: ResponsesBuilder);
-    /**
-     * A local reference for the `appConfiguration` service.
-     *
-     * @type {AppConfiguration}
-     * @access protected
-     * @ignore
-     */
-    _appConfiguration: AppConfiguration;
-    /**
-     * A local reference for the `responsesBuilder` service.
-     *
-     * @type {ResponsesBuilder}
-     * @access protected
-     * @ignore
-     */
-    _responsesBuilder: ResponsesBuilder;
-    /**
-     * Returns the middleware that shows the health information.
-     *
-     * @returns {ExpressMiddleware}
-     */
-    health(): ExpressMiddleware;
-}
-/**
- * Mounts the health route.
- *
- * @type {Controller}
- * @parent module:controllers
- */
-export const healthController: Controller;

package/types/controllers/common/index.d.ts

@@ -1,4 +0,0 @@
-import { configurationController } from "./configuration";
-import { healthController } from "./health";
-import { staticsController } from "./statics";
-export { configurationController, healthController, staticsController };