Expose Iterables

Add .keys(), .values() .entries() methods similar to the Map spec but instead they should return a Promise that resolves to an iterable.

Something like:

const keyv = new Keyv();
await keyv.set('foo', 'bar');
await keyv.set('fizz', 'buzz');

const keys = await keyv.keys();
for (const key of keys) {
  console.log(key);
}
// 'foo'
// 'fizz'

const values = await keyv.values();
for (const value of values) {
  console.log(value);
}
// 'bar'
// 'buzz'

const entries = await keyv.entries();
for (const [key, value] of entries) {
  console.log(`${key} => ${value}`);
}
// 'foo => bar'
// 'fizz => buzz'

[ApexioDaCoder]

This worked for me: keyv.opts.store.query('SELECT key FROM keyv;');

Edit: Changed from querying all to just the key. Thanks to HunteRoi.

[chocolateboy]

they should return a Promise that resolves to an iterable.

This requires all of the values to be slurped (or slurpable) before each method resolves, potentially incurring a huge cost in time and memory. What if there are a million records in a remote backend — taking, say, a minute to retrieve, and chewing through a gig of (mobile) RAM — but the caller only needs to check the first two?

async function any (keyv, predicate) {
    const entries = await keyv.entries() // XXX uh-oh

    for (const [key, value] of entries) {
        if (predicate(key, value)) {
            return true
        }
    }
}

It would be more efficient to wait for a result, then process it, then wait for another result, then process that etc. The usual way to do this is not with a recordset (e.g. a promise which returns an array) but with a cursor (e.g. an async iterator):

async function any (keyv, predicate) {
    for await (const [key, value] of keyv.entries()) {
        if (predicate(key, value)) {
            return true
        }
    }
}

While consuming them in this way requires ES2018 (or Babel or TypeScript), producing them does not (just as any library can spit out promises for consumption by async/await). And, of course, the desugared usage is always available as a fallback:

async function any (keyv, predicate) {
    const it = keyv.entries()[Symbol.asyncIterator]()

    while (true) {
        const { done, value: pair } = await it.next()

        if (done) {
            return false
        }

        if (predicate(...pair)) {
            return true
        }
    }
}