Promise.<function()> | Promise.<function()>Instantiate the codeGenerator service
Promise.<function()>Instantiate the counter service
Promise.<Object>Instantiate the delay service
Promise.<Object>Allow to import ES modules.
Promise.<Object>Instantiate the lock service
Promise.<function()>Instantiate the logging service
Promise.<function()>Instantiate the LRU Pool service
Promise.<function()>Instantiate the random service
Promise.<function()>Instantiate the random bytes service
Promise.<function()>Instantiate the random UUID service
Promise.<function()>Instantiate the resolve service
Promise.<string>Allow to resolve a path with the module system.
Promise.<function()>Instantiate the time service
Promise.<function()> \| Promise.<function()>
Instantiate the codeGenerator service
**Kind**: global function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.CHARS_SET] | Object | EXPLICIT_CHARS | An optional char set to pick cars into |
| [services.random] | Object | Math.random | An optional random function to replace the `Math.random` one used by default |
| [services.log] | Object | noop | An optional logging function |
**Example**
```js
import {
DEFAULT_LOGGER,
initCodeGenerator,
initLog,
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER,
});
const codeGenerator = await initCodeGenerator({
log,
});
```
### initCodeGenerator~codeGenerator([length]) ⇒ Promise.<String>
Returns a random code
**Kind**: inner method of [initCodeGenerator](#initCodeGenerator)
**Returns**: Promise.<String> - A promise of the generated code
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| [length] | Number | 6 | An optional custon code length (defaults to 6) |
**Example**
```js
console.log([
codeGenerator(),
codeGenerator(),
codeGenerator(),
]);
// Prints: ABCDEF,GHJKMN,PRSTUV
```
## initCounter(services) ⇒ Promise.<function()>
Instantiate the counter service
**Kind**: global function
**Returns**: Promise.<function()> - A promise of the counter function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.COUNTER] | Object | DEFAULT_COUNTER | An optional configuration object |
| [services.log] | Object | noop | An optional logging function |
**Example**
```js
import {
initCounter,
initLog,
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER
});
const counter = await initCounter({
COUNTER: { firstCount: 1 },
log,
});
```
### initCounter~counter() ⇒ Promise.<number>
Returns the current count and increment the counter
**Kind**: inner method of [initCounter](#initCounter)
**Returns**: Promise.<number> - A promise of the current count
**Example**
```js
console.log([
counter(),
counter(),
counter(),
]);
// Prints: 1,2,3
```
## initDelay(services) ⇒ Promise.<Object>
Instantiate the delay service
**Kind**: global function
**Returns**: Promise.<Object> - A promise of the delay service
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.log] | function | noop | A logging function |
**Example**
```js
import {
DEFAULT_LOGGER,
initDelay,
initLog,
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER
});
const delay = await initDelay({
log,
});
```
* [initDelay(services)](#initDelay) ⇒ Promise.<Object>
* [~create(delay)](#initDelay..create) ⇒ Promise
* [~clear(promise)](#initDelay..clear) ⇒ Promise
### initDelay~create(delay) ⇒ Promise
Create a new delay
**Kind**: inner method of [initDelay](#initDelay)
**Returns**: Promise - A promise to be resolved after that delay
or rejected if it is cancelled.
| Param | Type | Description |
| --- | --- | --- |
| delay | Number | The delay in ms |
**Example**
```js
await delay.create(1000);
console.log('1000 ms elapsed!');
```
### initDelay~clear(promise) ⇒ Promise
Cancel an earlier created delay
**Kind**: inner method of [initDelay](#initDelay)
**Returns**: Promise - A promise resolved when cancellation is done.
| Param | Type | Description |
| --- | --- | --- |
| promise | Promise | The promise of the delay to cancel |
**Example**
```js
const delayPromise = delay.create(1000);
if('timeout' === await delayPromise)
console.log('1000 ms elapsed!');
else
console.log('Cancelled!'));
```
## initImporter(path) ⇒ Promise.<Object>
Allow to import ES modules.
**Kind**: global function
**Returns**: Promise.<Object> - A promise of an imported module.
| Param | Type | Description |
| --- | --- | --- |
| path | string | The module path |
## initLock(services) ⇒ Promise.<Object>
Instantiate the lock service
**Kind**: global function
**Returns**: Promise.<Object> - A promise of the lock service
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.LOCKS_MAP] | Map | | A map to store le current locks (optional) |
| [services.LOCK_TIMEOUT] | Number | Infitiny | The timeout in milliseconds for the lock to be released. |
| [services.log] | function | | A logging function |
| [services.delay] | Object | | A delay service like the `common-services` one |
**Example**
```js
import {
DEFAULT_LOGGER,
initLog,
initDelay,
initLock
} from 'common-services';
import ms from 'ms';
const log = await initLog({
logger: DEFAULT_LOGGER
});
const delay = await initDelay({ log });
const lock = await initLock({
LOCK_TIMEOUT: ms('5s'),
delay,
log,
});
run();
async function run() {
// The following async jobs are done sequentially
// if they have the same `resourceKey` value
await Promise.all(asynTasks.map(async (asyncTask) => {
await lock.take(asyncTask.resourceKey);
await myAsyncStuff1(asyncTask);
await myAsyncStuff2(asyncTask);
await myAsyncStuff3(asyncTask);
lock.release(asyncTask.resourceKey);
});
}
```
* [initLock(services)](#initLock) ⇒ Promise.<Object>
* [~take(key)](#initLock..take) ⇒ Promise
* [~release(key)](#initLock..release) ⇒ void
### initLock~take(key) ⇒ Promise
Take the lock on the given resource key
**Kind**: inner method of [initLock](#initLock)
**Returns**: Promise - A promise to be resolved when the lock
is gained or rejected if the lock release
timeout is reached.
| Param | Type | Description |
| --- | --- | --- |
| key | String | A unique key for the locked resource |
### initLock~release(key) ⇒ void
Release the lock on the given resource key
**Kind**: inner method of [initLock](#initLock)
| Param | Type | Description |
| --- | --- | --- |
| key | String | A unique key for the resource to release |
## initLog(services) ⇒ Promise.<function()>
Instantiate the logging service
**Kind**: global function
**Returns**: Promise.<function()> - A promise of the logging function
| Param | Type | Description |
| --- | --- | --- |
| services | Object | The services to inject |
| services.logger | Object | The logger object that output the logs |
**Example**
```js
import {
DEFAULT_LOGGER,
initLog,
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER,
});
```
### initLog~log(type, ...args) ⇒ void
Logging function
**Kind**: inner method of [initLog](#initLog)
| Param | Type | Description |
| --- | --- | --- |
| type | String | Log type |
| ...args | \* | Log contents |
**Example**
```js
log('debug', 'Luke, I am your father!')
```
## initRandom(services) ⇒ Promise.<function()>
Instantiate the LRU Pool service
**Kind**: global function
**Returns**: Promise.<function()> - A promise of the LRUPool service
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.log] | Object | noop | A logging function |
**Example**
```js
import {
DEFAULT_LOGGER,
initLog,
initLRUPool
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER,
});
const random = await initLRUPool({
MAX_POOL_SIZE: 50,
poolManager: {
// ...
},
log,
});
```
### initRandom~random() ⇒ number
Returns a new random number
**Kind**: inner method of [initRandom](#initRandom)
**Returns**: number - The random number
**Example**
```js
random()
// Prints: 0.3141592653589793
```
## initRandom(services) ⇒ Promise.<function()>
Instantiate the random service
**Kind**: global function
**Returns**: Promise.<function()> - A promise of the random function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.log] | Object | noop | A logging function |
**Example**
```js
import {
DEFAULT_LOGGER,
initLog,
initRandom
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER,
});
const random = await initRandom({
log,
});
```
### initRandom~random() ⇒ number
Returns a new random number
**Kind**: inner method of [initRandom](#initRandom)
**Returns**: number - The random number
**Example**
```js
random()
// Prints: 0.3141592653589793
```
## initRandomBytes(services) ⇒ Promise.<function()>
Instantiate the random bytes service
**Kind**: global function
**Returns**: Promise.<function()> - A promise of the random bytes function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.log] | Object | noop | A logging function |
**Example**
```js
import {
DEFAULT_LOGGER,
initLog,
initRandomBytes
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER,
});
const randomBytes = await initRandomBytes({
log,
});
```
### initRandomBytes~randomBytes(length) ⇒ Promise.<Buffer>
Returns new random bytes
**Kind**: inner method of [initRandomBytes](#initRandomBytes)
**Returns**: Promise.<Buffer> - The random bytes
| Param | Type | Description |
| --- | --- | --- |
| length | number | The random bytes size |
**Example**
```js
await randomBytes(16)
// Prints: Promise.<function()>
Instantiate the random UUID service
**Kind**: global function
**Returns**: Promise.<function()> - A promise of the random UUID function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.log] | Object | noop | A logging function |
**Example**
```js
import {
DEFAULT_LOGGER,
initLog,
initRandomUUID
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER,
});
const randomUUID = await initRandomUUID({
log,
});
```
### initRandomUUID~randomUUID(options) ⇒ string
Returns a new random UUID
**Kind**: inner method of [initRandomUUID](#initRandomUUID)
**Returns**: string - The random UUID
| Param | Type | Description |
| --- | --- | --- |
| options | object | The node randomUUID options |
**Example**
```js
randomUUID()
// Prints: abbacaca-abba-caca-abba-cacaabbacaca
```
## initResolve(services) ⇒ Promise.<function()>
Instantiate the `resolve` service
**Kind**: global function
**Returns**: Promise.<function()> - A promise of the `resolve` service
| Param | Type | Description |
| --- | --- | --- |
| services | Object | The services to inject |
| services.MAIN_FILE_URL | String | An URL pointing to the main file run |
| [services.log] | function | A logging function |
**Example**
```js
import {
DEFAULT_LOGGER,
initLog,
initResolve,
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER,
});
const resolve = initResolve({
MAIN_FILE_URL: import.meta.url,
log,
});
resolve('./myfile.ts');
}
```
## resolve(path) ⇒ Promise.<string>
Allow to resolve a path with the module system.
**Kind**: global function
**Returns**: Promise.<string> - A promise of a fully qualified module path
| Param | Type | Description |
| --- | --- | --- |
| path | string | The serializable constants to gather |
## initTime(services) ⇒ Promise.<function()>
Instantiate the time service
**Kind**: global function
**Returns**: Promise.<function()> - A promise of the time function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| services | Object | | The services to inject |
| [services.log] | Object | noop | A logging function |
**Example**
```js
import {
DEFAULT_LOGGER,
initLog,
initTime,
} from 'common-services';
const log = await initLog({
logger: DEFAULT_LOGGER,
});
const time = await initTime({
log,
});
```
### initTime~time() ⇒ number
Returns the current timestamp
**Kind**: inner method of [initTime](#initTime)
**Returns**: number - The current timestamp
**Example**
```js
time()
// Prints: 1326585600000
```
# Authors
- [Nicolas Froidure](http://insertafter.com/en/index.html)
# License
[MIT](https://github.com/nfroidure/common-services/blob/main/LICENSE)
---
_Source: https://npm.io/package/common-services · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._