Mocks Server

The @mocks-server/logger package uses a hierarchical namespace system built on top of Winston. You can create a root logger and then derive child namespaces using the .namespace(label) method.

Key behaviors:

• Path Tracking: Each namespace includes its full path in the logs (e.g., [parent:child]).
• Log Storage: Logs are stored in two ways: a local store array specific to that namespace, and a single globalStore array that aggregates logs from all namespaces in the hierarchy.
• Level Inheritance: Child namespaces inherit the log level of their parent by default, but you can control this behavior using setLevel options.
• Event Emission: You can listen for changes to either the local namespace store or the global store using onChangeStore and onChangeGlobalStore.

const { Logger } = require("@mocks-server/logger");

const logger = new Logger();
const dbLogger = logger.namespace("db");
const dbConnectionLogger = dbLogger.namespace("connection");

dbConnectionLogger.debug("Connecting");
// Log format: 18:41:43:16 [debug][db:connection] Connecting

// Accessing logs
console.log(dbConnectionLogger.store); // Logs for 'connection' namespace
console.log(logger.globalStore);       // Logs for all namespaces

The @mocks-server/config library resolves option values from multiple sources. When load() or init() is called, it searches in the following order (from lowest to highest priority):

1. Default option value: The default property provided when the option is created.
2. Programmatic config: An object passed to the load() or init() methods.
3. Configuration file: Files searched in process.cwd() using [Cosmiconfig]. Supported formats include:
   • A [moduleName] property in package.json.
   • .[moduleName]rc (JSON or YAML).
   • .[moduleName]rc.json, .[moduleName]rc.yaml, .[moduleName].yml, .[moduleName]rc.js, or .[moduleName]rc.cjs.
   • [moduleName].config.js or [moduleName].config.cjs (can export an object, a function, or an async function).
4. Environment variables: Variables prepended with the moduleName in SCREAMING_SNAKE_CASE.
5. Process arguments: Command line arguments starting with --.

Namespaces allow for isolated configuration blocks, preventing collisions between different components or plugins. You can create namespaces using config.addNamespace(name). Namespaces can also be nested.

Accessing namespaced options via different sources

If you have a nested structure: moduleName: "mocks", namespaceA, and namespaceB containing optionA:

• Configuration files or programmatic objects:

  {
    "namespaceA": {
      "namespaceB": {
        "optionA": "foo-value"
      }
    }
  }

• Environment variables (use SCREAMING_SNAKE_CASE with all parent names): MOCKS_NAMESPACE_A_NAMESPACE_B_OPTION_A="foo-value"
• Command line arguments (use dot notation): --namespaceA.namespaceB.optionA="foo-value"

const config = new Config({ moduleName: "mocks" });

config
  .addNamespace("namespaceA")
  .addNamespace("namespaceB")
  .addOption({ name: "optionA", type: "string", default: "foo" });

Nested Collections is a collections manager that allows you to store items consisting of an id and a value. It supports a recursive structure where you can create descendant collections within a parent collection.

A key feature is the ability to retrieve all items from the entire hierarchy in a single flat array via the flat property, where each item is augmented with a collection path (e.g., parent:child:grandchild). It also supports event listening via onChange to react to any changes in the hierarchy.

const { NestedCollections } = require("@mocks-server/nested-collections");

const alerts = new NestedCollections("alerts");
alerts.set("root", "This alert is stored in the root collection");

const pluginsAlerts = alerts.collection("plugins");
pluginsAlerts.set("foo-alert-id", "This alert is stored in the plugins collection");

console.log(alerts.flat);
/*
[
  { id: 'root', value: '...', collection: 'alerts' },
  { id: 'foo-alert-id', value: '...', collection: 'alerts:plugins' }
]
*/

To use the configuration provider, instantiate the Config class, create namespaces for different components, and define options with specific types. After defining your configuration structure, call config.load() to resolve values from various sources (files, env vars, etc.). You can also listen for changes to option values using option.onChange().

const Config = require("@mocks-server/config");

// Create config
const config = new Config({ moduleName: "mocks" });

// Create namespace
const namespace = config.addNamespace("fooNamespace");

// Create option
const option = namespace.addOption({
  name: "fooOption",
  type: "string",
  default: "foo-value",
});

// Load configuration
config.load().then(() => {
  // Read value
  console.log(option.value);
  // Set value
  option.value = "foo-new-value";
});

// Listen to onChange events
option.onChange((newValue) => {
  console.log(`Option has a new value: ${newValue}`);
});