@rapidrest/core 1.0.1

package/docs/reference/classes/StringUtils.md

@@ -0,0 +1,169 @@
+[**@rapidrest/core**](../README.md)
+
+***
+
+[@rapidrest/core](../README.md) / StringUtils
+
+# Class: StringUtils
+
+Defined in: src/StringUtils.ts:10
+
+Utility functions for working with strings.
+
+## Author
+
+Jean-Philippe Steinmetz
+
+## Constructors
+
+### Constructor
+
+> **new StringUtils**(): `StringUtils`
+
+#### Returns
+
+`StringUtils`
+
+## Methods
+
+### findAndReplace()
+
+> `static` **findAndReplace**(`contents`, `variables`): `string`
+
+Defined in: src/StringUtils.ts:46
+
+Performs a search and replace on the provided contents with the map of variable replacements. The contents
+must use Mustache formatted tokens such as `{{toreplace}}`.
+
+#### Parameters
+
+##### contents
+
+`string`
+
+The stringt to perform the find and replace on.
+
+##### variables
+
+`any`
+
+A map of key=>value pairs to search for and replace.
+
+#### Returns
+
+`string`
+
+***
+
+### getParameters()
+
+> `static` **getParameters**(`str`): `string`[]
+
+Defined in: src/StringUtils.ts:18
+
+Returns a list of all parameters contained within the string. A parameter is a bracket delimited substring
+(e.g. /my/{key}/with/{id}).
+
+#### Parameters
+
+##### str
+
+`string`
+
+The string to search for parameters.
+
+#### Returns
+
+`string`[]
+
+A list of parameters contained in the provided string.
+
+***
+
+### replaceAll()
+
+> `static` **replaceAll**(`str`, `match`, `prefix`): `string`
+
+Defined in: src/StringUtils.ts:82
+
+Replaces all instances of the match regex pattern with the contents of the inner regular expression pattern for
+the given string.
+
+e.g.
+
+let result = replaceAll('/my/path/{id}', new RegExp('\{([^\}]+)\}'), ':');
+console.log(result); // -> /my/path/:id
+
+#### Parameters
+
+##### str
+
+`string`
+
+The string to perform replacement on.
+
+##### match
+
+The regular expression pattern to match containing an outer and inner pattern.
+
+`string` | `RegExp`
+
+##### prefix
+
+`string`
+
+The prefix to prepend the replacement text with.
+
+#### Returns
+
+`string`
+
+The fully replaced contents of the string.
+
+***
+
+### toCamelCase()
+
+> `static` **toCamelCase**(`str`): `string`
+
+Defined in: src/StringUtils.ts:100
+
+Converts the first character in the given string to be lowercase (e.g. myVariable).
+
+#### Parameters
+
+##### str
+
+`string`
+
+The string to convert to camelCase.
+
+#### Returns
+
+`string`
+
+The string converted to camelCase.
+
+***
+
+### toPascalCase()
+
+> `static` **toPascalCase**(`str`): `string`
+
+Defined in: src/StringUtils.ts:110
+
+Converts the first character in the given string to be uppercase (e.g. MyVariable).
+
+#### Parameters
+
+##### str
+
+`string`
+
+The string to convert to PascalCase.
+
+#### Returns
+
+`string`
+
+The string converted to PascalCase.

package/docs/reference/classes/ThreadPool.md

@@ -0,0 +1,249 @@
+[**@rapidrest/core**](../README.md)
+
+***
+
+[@rapidrest/core](../README.md) / ThreadPool
+
+# Class: ThreadPool
+
+Defined in: src/threads/ThreadPool.ts:62
+
+The `ThreadPool` class provides an interface for managing a pool of execution threads that can be used for parallel
+code execution. `ThreadPool` is a wrapper to the `worker_threads` API to add support for multiple `Worker` instances.
+By default, the pool will create *n* workers corresponding to the number of CPUs (physical + virtual) on the system.
+
+There are two ways to start worker threads with the pool.
+
+The first way is to set the `entry` option when calling the `start()` function. This will create a instance of the
+`worker_threads` APIs `Worker` class with the specified file as the entry point. Note that this file must be of
+type JavaScript (`.js` extension) as the underlying system does not support loading TypeScript. If the `args` option
+is set, the value will be passed in as the `workerData` to the entry file.
+
+The second way to start a worker thread is by setting the `worker` argument when calling the `start()` function. The
+specified `worker` file must contain a `default` export. The `default` export must be a class definition which
+extends the `ThreadWorker` abstract class interface. The file can be either JavaScript or TypeScript. When using
+this method the `start()` function will return only when all worker instances in each thread of the pool has
+successfully returned from its `start()` function. When the `args` option is set, the value(s) will be passed in to
+the constructor on instantiation by the thread executor.
+
+When the `restartOnExit` option is specified, the pool will automatically recreate and start a worker thread on
+the `exit event`.
+
+This class exposes worker messages via the `on()` callback handler function. Registering a callback handler via
+`on()` will propogate all messages from all underlying threads in the pool.
+
+## Author
+
+Jean-Philippe Steinmetz
+
+## Constructors
+
+### Constructor
+
+> **new ThreadPool**(`max`, `logger?`): `ThreadPool`
+
+Defined in: src/threads/ThreadPool.ts:98
+
+Creates a new `ThreadPool` instance with the specified defaults.
+
+#### Parameters
+
+##### max
+
+`number` = `0`
+
+The maximum number of threads to create. Default is `os.cpus().length`.
+
+##### logger?
+
+`any`
+
+The Winston logger instance to forward all worker thread logs to.
+
+#### Returns
+
+`ThreadPool`
+
+## Properties
+
+### workers
+
+> `readonly` **workers**: `Worker`[]
+
+Defined in: src/threads/ThreadPool.ts:74
+
+The list of active worker threads.
+
+## Accessors
+
+### max
+
+#### Get Signature
+
+> **get** **max**(): `number`
+
+Defined in: src/threads/ThreadPool.ts:81
+
+The maximum number of threads that can be created by the pool.
+
+##### Returns
+
+`number`
+
+***
+
+### size
+
+#### Get Signature
+
+> **get** **size**(): `number`
+
+Defined in: src/threads/ThreadPool.ts:88
+
+The number of active threads in the pool.
+
+##### Returns
+
+`number`
+
+## Methods
+
+### on()
+
+> **on**(`type`, `func`): `void`
+
+Defined in: src/threads/ThreadPool.ts:251
+
+Registers a new callback function to be notified when the given event type is fired.
+
+#### Parameters
+
+##### type
+
+`string`
+
+The event type to be notified of. Possible values are: `error`, `exit` and `message`.
+
+##### func
+
+[`WorkerCallback`](../type-aliases/WorkerCallback.md)
+
+The callback function to register.
+
+#### Returns
+
+`void`
+
+***
+
+### send()
+
+> **send**(`msg`): `void`
+
+Defined in: src/threads/ThreadPool.ts:264
+
+Sends the provided message to the next available worker thread. Messages are sent in a round-robin order.
+
+#### Parameters
+
+##### msg
+
+`any`
+
+The message to send the next available worker thread.
+
+#### Returns
+
+`void`
+
+***
+
+### sendAll()
+
+> **sendAll**(`msg`): `void`
+
+Defined in: src/threads/ThreadPool.ts:279
+
+Sends the provided message to all worker threads in the pool.
+
+#### Parameters
+
+##### msg
+
+`any`
+
+The message to send to all workers.
+
+#### Returns
+
+`void`
+
+***
+
+### sendTo()
+
+> **sendTo**(`id`, `msg`): `void`
+
+Defined in: src/threads/ThreadPool.ts:290
+
+Sends the provided message to the worker thread with the specified id.
+
+#### Parameters
+
+##### id
+
+`number`
+
+The id of the thread to send the message to.
+
+##### msg
+
+`any`
+
+The message to send the next available worker thread.
+
+#### Returns
+
+`void`
+
+***
+
+### start()
+
+> **start**(`options?`, `num?`): `Promise`\<`void`\>
+
+Defined in: src/threads/ThreadPool.ts:177
+
+Initializes the thread pool with the initial worker threads and begins execution.
+
+#### Parameters
+
+##### options?
+
+[`WorkerOptions`](../interfaces/WorkerOptions.md)
+
+The options to use when creating the worker thread.
+
+##### num?
+
+`number` = `...`
+
+The number of initial threads to create, cannot be greater than max. Default is `max`.
+
+#### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### stop()
+
+> **stop**(): `Promise`\<`void`\>
+
+Defined in: src/threads/ThreadPool.ts:224
+
+Stops all running thread executions.
+
+#### Returns
+
+`Promise`\<`void`\>

package/docs/reference/classes/ThreadWorker.md

@@ -0,0 +1,91 @@
+[**@rapidrest/core**](../README.md)
+
+***
+
+[@rapidrest/core](../README.md) / ThreadWorker
+
+# Abstract Class: ThreadWorker
+
+Defined in: src/threads/ThreadWorker.ts:29
+
+Provides a simple abstract interface for creating thread workers when using the `ThreadPool` system.
+
+## Author
+
+Jean-Philippe Steinmetz
+
+## Constructors
+
+### Constructor
+
+> **new ThreadWorker**(`logger`): `ThreadWorker`
+
+Defined in: src/threads/ThreadWorker.ts:32
+
+#### Parameters
+
+##### logger
+
+`any`
+
+#### Returns
+
+`ThreadWorker`
+
+## Properties
+
+### logger
+
+> `protected` **logger**: `any`
+
+Defined in: src/threads/ThreadWorker.ts:30
+
+## Methods
+
+### onMessage()
+
+> `abstract` **onMessage**(`msg`): `void` \| `Promise`\<`void`\>
+
+Defined in: src/threads/ThreadWorker.ts:41
+
+Callback function when a message is received from the thread pool manager.
+
+#### Parameters
+
+##### msg
+
+[`WorkerMessage`](../interfaces/WorkerMessage.md)
+
+The message that was received.
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>
+
+***
+
+### start()
+
+> `abstract` **start**(): `void` \| `Promise`\<`void`\>
+
+Defined in: src/threads/ThreadWorker.ts:46
+
+Starts execution of the thread worker.
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>
+
+***
+
+### stop()
+
+> `abstract` **stop**(): `void` \| `Promise`\<`void`\>
+
+Defined in: src/threads/ThreadWorker.ts:51
+
+Stops execution of all work and shuts down the thread worker.
+
+#### Returns
+
+`void` \| `Promise`\<`void`\>