To account for people that might use a large number of enmaps in the same project, I've created a new `multi()` method that can be used to instanciate multiple peristent enmaps together.

The method takes 3 arguments:

• An array of names for the enmaps to be created.

• A Provider (not instanciated), from any of the available ones.

• An options object containing any of the options needed to instanciate the provider. Do not add name to this, as it will use the names in the array instead.

Below, an example that uses destructuring:

Enmap ⇐ Map

A enhanced Map structure with additional utility methods. Can be made persistent

Kind: global class Extends: Map

• ⇐ Map

  • instance

    • ⇒ Promise.

enmap.fetchEverything() ⇒ Promise.

Fetches every key from the persistent enmap and loads them into the current enmap value.

Kind: instance method of Returns: Promise. - The enmap containing all values, as a promise..

enmap.fetch(keyOrKeys) ⇒ Promise.

Force fetch one or more key values from the enmap. If the database has changed, that new value is used.

Kind: instance method of Returns: Promise. - A single value if requested, or a non-persistent enmap of keys if an array is requested.

enmap.evict(keyOrArrayOfKeys)

Removes a key from the cache - useful when using the fetchAll feature.

Kind: instance method of

enmap.autonum() ⇒ number

Generates an automatic numerical key for inserting a new value.

Kind: instance method of Returns: number - The generated key number. Example

enmap.changed(cb)

Function called whenever data changes within Enmap after the initial load. Can be used to detect if another part of your code changed a value in enmap and react on it.

Kind: instance method of

Example

enmap.set(key, val, path) ⇒ Map

Set the value in Enmap.

Kind: instance method of Returns: Map - The Enmap.

Example

enmap.setProp(key, path, val) ⇒ Map

Modify the property of a value inside the enmap, if the value is an object or array. This is a shortcut to loading the key, changing the value, and setting it back.

Kind: instance method of Returns: Map - The EnMap.

enmap.push(key, val, path, allowDupes) ⇒ Map

Push to an array value in Enmap.

Kind: instance method of Returns: Map - The EnMap.

Example

enmap.pushIn(key, path, val, allowDupes) ⇒ Map

Push to an array element inside an Object or Array element in Enmap.

Kind: instance method of Returns: Map - The EnMap.

enmap.math(key, operation, operand, path) ⇒ Map

Executes a mathematical operation on a value and saves it in the enmap.

Kind: instance method of Returns: Map - The EnMap.

Example

enmap.inc(key, path) ⇒ Map

Increments a key's value or property by 1. Value must be a number, or a path to a number.

Kind: instance method of Returns: Map - The EnMap.

Example

enmap.dec(key, path) ⇒ Map

Decrements a key's value or property by 1. Value must be a number, or a path to a number.

Kind: instance method of Returns: Map - The EnMap.

Example

enmap.get(key, path) ⇒ *

Retrieves a key from the enmap. If fetchAll is false, returns a promise.

Kind: instance method of Returns: * - The value for this key.

Example

enmap.getProp(key, path) ⇒ *

Returns the specific property within a stored value. If the key does not exist or the value is not an object, throws an error.

Kind: instance method of Returns: * - The value of the property obtained.

enmap.has(key, path) ⇒ boolean

Returns whether or not the key exists in the Enmap.

Kind: instance method of

Example

enmap.hasProp(key, path) ⇒ boolean

Returns whether or not the property exists within an object or array value in enmap.

Kind: instance method of Returns: boolean - Whether the property exists.

enmap.delete(key, path)

Deletes a key in the Enmap.

Kind: instance method of

enmap.deleteProp(key, path)

Delete a property from an object or array value in Enmap.

Kind: instance method of

enmap.deleteAll(bulk)

Calls the delete() method on all items that have it.

Kind: instance method of

enmap.remove(key, val, path) ⇒ Map

Remove a value in an Array or Object element in Enmap. Note that this only works for values, not keys. Complex values such as objects and arrays will not be removed this way.

Kind: instance method of Returns: Map - The EnMap.

enmap.removeFrom(key, path, val) ⇒ Map

Remove a value from an Array or Object property inside an Array or Object element in Enmap. Confusing? Sure is.

Kind: instance method of Returns: Map - The EnMap.

enmap.array() ⇒ Array

Creates an ordered array of the values of this Enmap. The array will only be reconstructed if an item is added to or removed from the Enmap, or if you change the length of the array itself. If you don't want this caching behaviour, use Array.from(enmap.values()) instead.

Kind: instance method of

enmap.keyArray() ⇒ Array

Creates an ordered array of the keys of this Enmap The array will only be reconstructed if an item is added to or removed from the Enmap, or if you change the length of the array itself. If you don't want this caching behaviour, use Array.from(enmap.keys()) instead.

Kind: instance method of

enmap.random([count]) ⇒ * | Array.

Obtains random value(s) from this Enmap. This relies on .

Kind: instance method of Returns: * | Array. - The single value if count is undefined, or an array of values of count length

enmap.randomKey([count]) ⇒ * | Array.

Obtains random key(s) from this Enmap. This relies on

Kind: instance method of Returns: * | Array. - The single key if count is undefined, or an array of keys of count length

enmap.findAll(prop, value) ⇒ Array

Searches for all items where their specified property's value is identical to the given value (item[prop] === value).

Kind: instance method of

Example

enmap.find(propOrFn, [value]) ⇒ *

Searches for a single item where its specified property's value is identical to the given value (item[prop] === value), or the given function returns a truthy value. In the latter case, this is identical to .

All Enmap used in Discord.js are mapped using their `id` property, and if you want to find by id you should use the `get` method. See [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get) for details.

Kind: instance method of

Example

Example

enmap.exists(prop, value) ⇒ boolean

Searches for the existence of a single item where its specified property's value is identical to the given value (item[prop] === value).

Do not use this to check for an item by its ID. Instead, use `enmap.has(id)`. See [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has) for details.

Kind: instance method of

Example

enmap.filter(fn, [thisArg]) ⇒

Identical to , but returns a Enmap instead of an Array.

Kind: instance method of

enmap.filterArray(fn, [thisArg]) ⇒ Array

Identical to .

Kind: instance method of

enmap.map(fn, [thisArg]) ⇒ Array

Identical to .

Kind: instance method of

enmap.some(fn, [thisArg]) ⇒ boolean

Identical to .

Kind: instance method of

enmap.every(fn, [thisArg]) ⇒ boolean

Identical to .

Kind: instance method of

enmap.reduce(fn, [initialValue]) ⇒ *

Identical to .

Kind: instance method of

enmap.clone() ⇒

Creates an identical shallow copy of this Enmap.

Kind: instance method of Example

enmap.concat(...enmaps) ⇒

Combines this Enmap with others into a new Enmap. None of the source Enmaps are modified.

Kind: instance method of

Example

enmap.equals(enmap) ⇒ boolean

Checks if this Enmap shares identical key-value pairings with another. This is different to checking for equality using equal-signs, because the Enmaps may be different objects, but contain the same data.

Kind: instance method of Returns: boolean - Whether the Enmaps have identical contents

Enmap.multi(names, Provider, options) ⇒ Array.

Initialize multiple Enmaps easily.

Kind: static method of Returns: Array. - An array of initialized Enmaps.

Example

Enmap.migrate(source, target)

Migrates an Enmap from version 3 or lower to a Version 4 enmap, which is locked to sqlite backend only. Version 4 uses a different way of storing data, so is not directly compatible with version 3 data. Note that this migration also makes the data unuseable with version 3, so it should only be used to migrate once.

Kind: static method of

Example

Pre-Requisites

In order to install Enmap, you'll need a few things installed on your machine. First off, you need NodeJS (version 8 or higher required). For Windows and MacOS, simply download and install from the website. For Linux, see this page for installation.

Enmap v3 is no longer maintained on NPM and is only available on Github. You will need to install a git tool on your computer to install it.

Next, enmap has a specific pre-requisite which is needed for the sqlite dependency. How to install these depends on your operating system, so see below for instructions:

Installing enmap

To install Enmap in your project, all you need to to is run the following command in your project folder:

This may take a few minutes, then you're ready to use it.

Inside your script, initialize a new Enmap:

const Enmap = require("enmap");

// Initialize an instance of Enmap
const myCollection = new Enmap();

// Adding data is simply a `set` command: 
myCollection.set("myKey", "a value");

// Getting a value is done by key 
let result = myCollection.get("myKey");

Some quick docs:

Persistence requires an additional Provider module.

Official Enmap Providers:

• : Recommended, supports sharding locally.

• : Best for sharding if you can install a rethinkdb server. Supports updating from the database on all shards (enmap-rethink 2.1.0 and higher)

As described in the home page, one disadvantage of Enmap is that it loads all your data in memory, so you're sacrificing RAM in order to gain speed. In larger projects, this might become a concern fairly quickly - or when using larger data sets that take more memory.

For this purpose, I surrepticiously added a new option somewhere around Enmap 2.0 called "fetchAll", which defaults to "true" if you don't specify it - which is the old behaviour, and current default at the same time. But, if you set fetchAll to false in the Enmap options, data is not fetched on load.

What does it mean if the data isn't loaded?

If fetchAll is set to false, no data (by default) will be loaded from the database - the Enmap will be completely empty. This means that doing a .size check returns 0, looping and filtering doesn't return anything, and get() requests all return null.

Ok but... how's that useful? It's useful because if you don't need the data, it's not loaded. To load data, there are 2 different methods available.

Fetching Data

• enmap.fetchEverything() will, of course, fetch all the data from the database - this is the method that's called on init() if fetchAll is true. This means you can stagger your loading time, or that you can decide, later, under certain conditions, you do want to load everything.

• enmap.fetch(key) can fetch a single key from the database, saves it to enmap, and returns a promise with the fetched value.

That's it!

Yup. Those are the only things you really need to know for the current version of Enmap's fetchAll feature.

Upcoming Features:

I'm working on the following features in future versions of enmap, related to fetch methods:

• Add the ability to check if the DB has a key without fetching

• Add a method to uncache a key from enmap

• Add a method to count keys in the DB (like enmap.keyCount() maybe?)

Enmap is a great way to store structured data, and offers a few helper features that directly affect both objects and arrays.

Let's assume for a moment that we want to store the following data structure in Enmap:

This structure has 5 "properties": first, second, changeme, isCool, sub. The sub property has 2 properties of its own, yay and thing.

To store this structure in Enmap, you can use a variable, or just straight-up write the object:

Note: All further methods require the value to be an object. If you attempt to get, set, modify or remove using the below methods and your value isn't an object, Enmap will throw an error.

Getting properties

Retrieving a specific property from an object is done through the get() method, by specifying both the key and the "path" to the property you want.

The exact method is <Enmap>.get(key, path).

Checking if a property exists

You can also check if a specific property exists or not. This is done through the has method, with a key, and path to the property:

Modifying Properties

There are a few various ways to modify properties of both Objects and Arrays. The very basic way to set a property on an object or array is through .set(key, value, path) like the following examples:

As you can see, setProp() and getProp() work on the same concept that the path can be as complex as you want.

Arrays have additional helper methods, .

Now that we have a functional Enmap structure (which we'll always refer to as myEnmap), we're ready to start writing data to it, and getting data from it.

The code samples on this page assume that you have correctly initialized myEnmap, and awaited its initialization if it's persistent.

Writing Data

In terms of Enmap, "writing", "adding" and "editing" data is essentially the same thing. When using the basic set() method, if the key does not exist it's created, and if it does, it's modified.

Enmap supports most native JavaScript data types, with a few small exceptions.

• Complex objects like Set(), Map(), etc, are not supported.

• Class instances and Functions are not supported.

As a general rule, except for null and undefined, anything that can be handled by JSON.stringify() will work as expected in Enmap. This includes:

• String

• Number

• Integer

Objects and Arrays are a little more complex to deal with, so they have their own page. See for more information.

The usage for the set() method is simple:

• key must be a string or integer. A key should be unique, otherwise it will be overwritten by new values using the same key.

• value must be a supported native data type as mentioned above.

Here are a few examples of writing simple data values:

Retrieving Data

Getting data back from an Enmap is just as simple as writing to it. All you need is the key of what you want to retrieve, and you get its value back!

That's pretty much it for only retrieiving a single data value. There are more complex operations that are available, take a look at for the more advanced things you can do on Enmap's data!

Enmap stands for "Enhanced Map", and is a data structure based on the native JavaScript Map() structure with additional helper methods from the native Array() structure.

Enmap also offers persistence, which means it will automatically save everything to save to it in a database, in the background, without any additional code or delays.

Why Enmap?

While there are other better-known systems that offer some features of Enmap, especially caching in memory, Enmap is targetted specifically to newer users of JavaScript that might not want to deal with complicated systems like Redis for caching, or database queries.

Advantage/Disadvantage

Here are some advantages of using Enmap:

• Simple to Install: Enmap itself only requires a simple npm install command to install and use, and a single line to initialize. When using persistent providers, some additional pre-requisites are necessary. .

• Simple to Use: Basic enmap usage can be completely done with 1-2 lines of initalization, and 3 commands, set(), get() and delete().

Some disadvantages, compared to using a database connection directly:

• More memory use: Since Enmap resides in memory and (by default) all its data is loaded when it starts, your entire data resides in RAM. When using a large amount of data on a low-end computer or VPS, this might be an issue for some users.

• Limited power: You can have multiple Enmap "tables" loaded in your app, but they do not and cannot have relationships between them. Basically, one enmap value can't refer to another value in another enmap. This is something databases can be very good at, but due to the simplistic nature of Enmap, it's not possible here.

While Enmap is a Map enhanced with Array methods, Enmap also offers some enhanced array methods for the data stored inside of it. Talk about ArrayCeption!

So what do I mean by methods for your stored data? I mean that you can store arrays inside Enmap, and directly push, pull, add and remove from those arrays. There are methods to work both on direct arrays, as well as arrays stored inside of an object.

Let's take a look at two example entries in enmap that we can use. The first is a direct array, the second is an array inside an object.

myEnmap.set("simpleArray", [1,2,3,4,5]);

myEnmap.set("arrInObj", {
  name: "Bob",
  aliases: ["Bobby", "Robert"]
});

Adding to the array

There are two methods to push to an array, one for simple arrays and one for arrays inside objects. Pushing in an enmap array is the same as a regular array push: it adds the element to the end of the array.

The second parameter in pushIn is the "path" to the array in an object. It works the same as the properties path used in .

Removing from the array

Similarly, you can remove from an array. Note, however, that this will only work if you're removing a string or number. Removing an object from an array is not supported.