pip-services3-commons-node/src/commands/index.ts

Portable abstractions and patterns for Pip.Services in Node.js

/** 
 * @module commands 
 * 
 * Todo: Rewrite this description.
 * 
 * @preferred
 * Contains implementation of Command design patterns, which can be used to implement various remote procedure calls (RPCs).
 * RPCs replace unique calls with universal "message transfer" calls, in which the message itself contains the called method's 
 * signature, as well as the parameters to pass for execution. 
 * 
 * When designing calls of methods/commands using the Command design pattern, uniform interfaces can be used, which, in turn, 
 * allow any amount of concrete methods to be called.
 * 
 * Command design patterns can be used for intercepting messages and for various logging implementations. 
 * 
 * These design patterns allow us to create [[ICommandable Commandable Interfaces]], which are completely universal. If an object  
 * extends [[ICommandable]] and returns a [[CommandSet]], then we can implement, with minimal code, a commandable client for this 
 * object, using various technologies.
 * 
 * - [[ICommandable Commandable Interfaces]] – part of the command design pattern, used to make classes with certain logic, which 
 * are capable of receiving and processing commands in this universal form.   
 * 
 * - [[ICommandInterceptor Command interceptors]] – modify the message execution pipeline. Command interceptors are used to intercept 
 * calls, perform a set of actions, and, optionally, cancel the command's actual execution by simply returning a result. This logic 
 * is used in  aspect-oriented programming. Aspect-oriented programming contains perpendicular logic (aspects, for example: logging, 
 * caching, blocking), which can be removed from the business logic and added to these perpendicular calls. When using interceptors, 
 * a command can pass through an execution chain, consisting of interceptors, which can: 
 *     - simply make some note of the command, notify, log, get metrics, or do some other passive task; or
 *     - intercept the command completely and, for example, return a previous record of the call from the cache. A command’s return 
 *     value can also be intercepted in a similar manner: the result can be written to cache, so that the next call doesn’t have to be made. 
 * 
 * - [[InterceptedCommand Intercepted commands]] are used as pattern decorators in the command design pattern. They are represented as regular 
 * commands, but run their own logic before calling the actual command. 
 */
export { ICommand } from './ICommand';
export { ICommandInterceptor } from './ICommandInterceptor';
export { IEvent } from './IEvent';
export { IEventListener } from './IEventListener';
export { Command } from './Command';
export { CommandSet } from './CommandSet';
export { Event } from './Event';
export { InterceptedCommand } from './InterceptedCommand';
export { ICommandable } from './ICommandable';